├── Galador.Reflection.chm
├── TestAndroid
    ├── Resources
    │   ├── drawable
    │   │   └── Icon.png
    │   ├── values
    │   │   └── Strings.xml
    │   ├── layout
    │   │   ├── Main.axml
    │   │   └── LayoutTest.axml
    │   └── AboutResources.txt
    ├── Properties
    │   ├── AndroidManifest.xml
    │   └── AssemblyInfo.cs
    ├── MainActivity.cs
    ├── packages.config
    ├── TestAdapter.cs
    └── TestAndroid.csproj
├── TestApp
    ├── App.config
    ├── TestForm.cs
    ├── TestApp.csproj
    ├── Program.cs
    ├── StreamTests.cs
    ├── RegistryTests.cs
    ├── PathTests.cs
    ├── TestForm.Designer.cs
    ├── DocumentTest.cs
    └── TestForm.resx
├── Galador.Reflection
    ├── Serialization
    │   ├── IDeserialized.cs
    │   ├── PropertyPathInfo.cs
    │   ├── ObjectData.cs
    │   ├── LostData.cs
    │   ├── SerializationSettings.cs
    │   ├── IO
    │   │   ├── IPrimitiveReader.cs
    │   │   ├── IPrimitiveWriter.cs
    │   │   ├── TokenPrimitiveWriter.cs
    │   │   ├── PrimitiveTextWriter.cs
    │   │   ├── PrimitiveBinaryWriter.cs
    │   │   ├── PrimitiveBinaryReader.cs
    │   │   └── PrimitiveTextReader.cs
    │   ├── Serializer.cs
    │   ├── SerializationAttributes.cs
    │   └── Writer.cs
    ├── Galador.Reflection.csproj
    ├── README.txt
    ├── Utils
    │   ├── ReferenceEqualityComparer.cs
    │   ├── KnownAssemblies.cs
    │   ├── MemberList.cs
    │   ├── CollectionEx.cs
    │   ├── FastMethod.cs
    │   ├── TypeTree.cs
    │   ├── PrimitiveType.cs
    │   └── TypeDescription.cs
    └── Registry.cs
├── LICENSE.txt
├── TestNETCore
    ├── TestNETCore.csproj
    └── Program.cs
├── .gitattributes
├── SHBDocumentation.shfbproj
├── Galador.Reflection.sln
├── .gitignore
├── registry.md
└── README.md


/Galador.Reflection.chm:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/superlloyd/Galador.Reflection/HEAD/Galador.Reflection.chm


--------------------------------------------------------------------------------
/TestAndroid/Resources/drawable/Icon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/superlloyd/Galador.Reflection/HEAD/TestAndroid/Resources/drawable/Icon.png


--------------------------------------------------------------------------------
/TestApp/App.config:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8"?>
2 | <configuration>
3 |     <startup> 
4 |         <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.7.2"/>
5 |     </startup>
6 | </configuration>
7 | 


--------------------------------------------------------------------------------
/TestAndroid/Resources/values/Strings.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8"?>
2 | <resources>
3 |     <string name="Hello">Start Tests</string>
4 |     <string name="ApplicationName">TestAndroid</string>
5 | </resources>
6 | 


--------------------------------------------------------------------------------
/TestAndroid/Properties/AndroidManifest.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8"?>
2 | <manifest xmlns:android="http://schemas.android.com/apk/res/android" package="TestAndroid.TestAndroid" android:versionCode="1" android:versionName="1.0">
3 | 	<uses-sdk android:minSdkVersion="16" android:targetSdkVersion="28" />
4 | 	<application android:label="TestAndroid"></application>
5 | </manifest>


--------------------------------------------------------------------------------
/TestApp/TestForm.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using System.ComponentModel;
 4 | using System.Data;
 5 | using System.Drawing;
 6 | using System.Linq;
 7 | using System.Text;
 8 | using System.Threading.Tasks;
 9 | using System.Windows.Forms;
10 | 
11 | namespace TestApp
12 | {
13 |     public partial class TestForm : Form
14 |     {
15 |         public TestForm()
16 |         {
17 |             InitializeComponent();
18 |         }
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/Galador.Reflection/Serialization/IDeserialized.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using System.Text;
 4 | 
 5 | namespace Galador.Reflection.Serialization
 6 | {
 7 |     /// <summary>
 8 |     /// This method will be called on deserialized object for further deserialization 
 9 |     /// post processing. It will be called immediately on value type and when the whole
10 |     /// object tree has been process on value type.
11 |     /// </summary>
12 |     public interface IDeserialized
13 |     {
14 |         /// <summary>
15 |         /// On completion of the deserialization process this method will be called.
16 |         /// </summary>
17 |         void OnDeserialized(LostData lost);
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/TestAndroid/Resources/layout/Main.axml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
 3 |     android:orientation="vertical"
 4 |     android:layout_width="match_parent"
 5 |     android:layout_height="match_parent">
 6 |     <Button
 7 |         android:id="@+id/MyButton"
 8 |         android:layout_width="match_parent"
 9 |         android:layout_height="wrap_content"
10 |         android:text="@string/Hello" />
11 |     <ListView
12 |         android:minWidth="25px"
13 |         android:minHeight="25px"
14 |         android:layout_width="match_parent"
15 |         android:layout_height="match_parent"
16 |         android:id="@+id/listView1" />
17 | </LinearLayout>


--------------------------------------------------------------------------------
/Galador.Reflection/Galador.Reflection.csproj:
--------------------------------------------------------------------------------
 1 | <Project Sdk="Microsoft.NET.Sdk">
 2 | 
 3 |   <PropertyGroup>
 4 |     <TargetFrameworks>net472;net10.0</TargetFrameworks>
 5 | 	  <LangVersion>preview</LangVersion>
 6 | 	  <Nullable>enable</Nullable>
 7 |   </PropertyGroup>
 8 | 
 9 | 	<!-- Nuget publish data -->
10 | 	<PropertyGroup>
11 | 	  <PackageId>Galador.Reflection</PackageId>
12 | 	  <Authors>Lloyd Dupont</Authors>
13 | 	  <Version>1.1.0</Version>
14 | 	  <PackageProjectUrl>https://github.com/superlloyd/Galador.Reflection</PackageProjectUrl>
15 | 	  <Description>Here one can find:
16 | - A binary, strongly typed, yet verssion tolerant serializer (Serializer class).
17 | - Yet another type resolver (Registry class).
18 | - Fast Reflection type (FastType class)</Description>
19 | 	</PropertyGroup>
20 | 
21 | </Project>
22 | 


--------------------------------------------------------------------------------
/Galador.Reflection/README.txt:
--------------------------------------------------------------------------------
 1 | .NET Framework and .NET Core target both use Emit and DynamicMethod
 2 | .NET Standard profile no emit/DynamicMethod, since Android and iOS don't support emit (only compile but not run), hence using .NET Standard 2.0 profile.
 3 | .NET Framework also use System.Configuration and App.Settings[] to turn log traces on or off at launch time
 4 | 
 5 | How to Publish
 6 | ==============
 7 | 0] Manage API keys @ https://www.nuget.org/account/apikeys
 8 | 1] https://docs.microsoft.com/en-us/nuget/create-packages/creating-a-package-dotnet-cli
 9 | 2] https://docs.microsoft.com/en-us/nuget/nuget-org/publish-a-package
10 | 3] run those commands
11 | dotnet pack  -c Release .\Galador.Reflection\Galador.Reflection.csproj
12 | cd .\Galador.Reflection\bin\Release\
13 | ..\..\..\..\nuget push .\Galador.Reflection.1.1.0.nupkg -Source https://api.nuget.org/v3/index.json -ApiKey  '=== INSERT API KEY HERE ==='
14 | 
15 | 


--------------------------------------------------------------------------------
/TestApp/TestApp.csproj:
--------------------------------------------------------------------------------
 1 | <Project Sdk="Microsoft.NET.Sdk">
 2 | 
 3 |   <PropertyGroup>
 4 | 	<TargetFramework>net9.0-windows</TargetFramework>
 5 |     <UseWindowsForms>true</UseWindowsForms>
 6 |     <AllowUnsafeBlocks>True</AllowUnsafeBlocks>
 7 | 	  <Nullable>enable</Nullable>
 8 | 	  <LangVersion>preview</LangVersion>
 9 | 	  <IsPackable>false</IsPackable>
10 |   </PropertyGroup>
11 | 
12 |   <ItemGroup>
13 | 	  <PackageReference Include="coverlet.collector" Version="6.0.2" />
14 | 	  <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.12.0" />
15 | 	  <PackageReference Include="xunit" Version="2.9.2" />
16 | 	  <PackageReference Include="xunit.runner.visualstudio" Version="2.8.2" />
17 |   </ItemGroup>
18 | 
19 | 	<ItemGroup>
20 | 		<Using Include="Xunit" />
21 | 	</ItemGroup>
22 | 
23 | 	<ItemGroup>
24 |     <ProjectReference Include="..\Galador.Reflection\Galador.Reflection.csproj" />
25 |   </ItemGroup>
26 |     
27 | </Project>


--------------------------------------------------------------------------------
/Galador.Reflection/Utils/ReferenceEqualityComparer.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using System.Runtime.CompilerServices;
 4 | using System.Text;
 5 | 
 6 | namespace Galador.Reflection.Utils
 7 | {
 8 |     public class ReferenceEqualityComparer<T> : IEqualityComparer<T>
 9 |         where T : class
10 |     {
11 |         public int GetHashCode(T value)
12 |         {
13 |             return RuntimeHelpers.GetHashCode(value);
14 |         }
15 | 
16 |         public bool Equals(T left, T right)
17 |         {
18 |             return Object.ReferenceEquals(left, right);
19 |         }
20 |     }
21 | 
22 |     public class ReferenceEqualityComparer : IEqualityComparer<object>
23 |     {
24 |         public int GetHashCode(object value)
25 |         {
26 |             return RuntimeHelpers.GetHashCode(value);
27 |         }
28 | 
29 |         bool IEqualityComparer<object>.Equals(object left, object right)
30 |         {
31 |             return Object.ReferenceEquals(left, right);
32 |         }
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/TestAndroid/Resources/layout/LayoutTest.axml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
 3 |     android:layout_width="match_parent"
 4 |     android:layout_height="match_parent">
 5 |     <CheckBox
 6 |         android:layout_width="wrap_content"
 7 |         android:layout_height="wrap_content"
 8 |         android:id="@+id/resultCheckBox"
 9 |         android:layout_column="1"
10 |         android:layout_alignParentEnd="true"
11 |         android:clickable="false"
12 |         android:enabled="false" />
13 |     <TextView
14 |         android:text="Medium Text"
15 |         android:textAppearance="?android:attr/textAppearanceSmall"
16 |         android:layout_width="match_parent"
17 |         android:layout_height="wrap_content"
18 |         android:id="@+id/resultMethod"
19 |         android:layout_column="0"
20 |         android:layout_marginLeft="5dip"
21 |         android:layout_marginEnd="30dip"
22 |         android:layout_marginTop="5dip" />
23 | </RelativeLayout>


--------------------------------------------------------------------------------
/TestApp/Program.cs:
--------------------------------------------------------------------------------
 1 | #if COMMAND_LINE
 2 | using Galador.Reflection.Serialization;
 3 | using System;
 4 | using System.Collections.Generic;
 5 | using System.Linq;
 6 | using System.Text;
 7 | using System.Threading.Tasks;
 8 | 
 9 | namespace TestApp
10 | {
11 |     class Program
12 |     {
13 |         [STAThread]
14 |         static void Main(string[] args)
15 |         {
16 |             var tSer = new SerializationTests();
17 | 
18 |             tSer.CheckWriteIsFastEnough();
19 |             tSer.CheckReadIsFastEnough();
20 | 
21 |             var ctxt = new Context();
22 |             var csharp = ctxt.GenerateCSharpCode("Generated"
23 |                 , typeof(SerializationTests.BigClass)
24 |                 , typeof(SerializationTests.SimpleClass<Dictionary<int, string>>)
25 |                 , typeof(SerializationTests.BList)
26 |                 , typeof(SerializationTests.Serial2)
27 |                 , typeof(SerializationTests.Generic01<int, string>)
28 |                 );
29 | 
30 |             tSer.WinFormTest();
31 |         }
32 | 
33 |     }
34 | }
35 | #endif


--------------------------------------------------------------------------------
/Galador.Reflection/Serialization/PropertyPathInfo.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using System.IO;
 4 | using System.Linq;
 5 | using System.Text;
 6 | using System.Threading.Tasks;
 7 | 
 8 | namespace Galador.Reflection.Serialization;
 9 | 
10 | /// <summary>
11 | /// This is a debugging class, that hold the path of the currently reading item.
12 | /// In case of 2 path resolving to the same item this will be displayed as a warning
13 | /// (the warning only happen for collection now).
14 | /// This can happen since the deserializer rather use exiting property / item (when they exits) 
15 | /// than creating new ones. and also use public property and setter when possible.
16 | /// </summary>
17 | public class PropertyPathInfo
18 | {
19 |     List<string> _path = new List<string>();
20 | 
21 |     public void Push()
22 |         => _path.Add(string.Empty);
23 |     public void Pop()
24 |         => _path.RemoveAt(_path.Count - 1);
25 |     public void Set(string name)
26 |         => _path[_path.Count - 1] = name;
27 |     override public string ToString()
28 |         => string.Join("", _path);
29 | }
30 | 


--------------------------------------------------------------------------------
/LICENSE.txt:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) Lloyd Dupont
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.


--------------------------------------------------------------------------------
/TestAndroid/Properties/AssemblyInfo.cs:
--------------------------------------------------------------------------------
 1 | using System.Reflection;
 2 | using System.Runtime.CompilerServices;
 3 | using System.Runtime.InteropServices;
 4 | using Android.App;
 5 | 
 6 | // General Information about an assembly is controlled through the following 
 7 | // set of attributes. Change these attribute values to modify the information
 8 | // associated with an assembly.
 9 | [assembly: AssemblyTitle("TestAndroid")]
10 | [assembly: AssemblyDescription("")]
11 | [assembly: AssemblyConfiguration("")]
12 | [assembly: AssemblyCompany("")]
13 | [assembly: AssemblyProduct("TestAndroid")]
14 | [assembly: AssemblyCopyright("Copyright ©  2016")]
15 | [assembly: AssemblyTrademark("")]
16 | [assembly: AssemblyCulture("")]
17 | [assembly: ComVisible(false)]
18 | 
19 | // Version information for an assembly consists of the following four values:
20 | //
21 | //      Major Version
22 | //      Minor Version 
23 | //      Build Number
24 | //      Revision
25 | //
26 | // You can specify all the values or you can default the Build and Revision Numbers 
27 | // by using the '*' as shown below:
28 | // [assembly: AssemblyVersion("1.0.*")]
29 | [assembly: AssemblyVersion("1.0.0.0")]
30 | [assembly: AssemblyFileVersion("1.0.0.0")]
31 | 


--------------------------------------------------------------------------------
/TestNETCore/TestNETCore.csproj:
--------------------------------------------------------------------------------
 1 | <Project Sdk="Microsoft.NET.Sdk">
 2 | 
 3 |   <PropertyGroup>
 4 |     <OutputType>Exe</OutputType>
 5 |     <TargetFramework>netcoreapp2.1</TargetFramework>
 6 |   </PropertyGroup>
 7 | 
 8 |   <ItemGroup>
 9 |     <Compile Include="..\TestApp\PathTests.cs" Link="PathTests.cs" />
10 |     <Compile Include="..\TestApp\RegistryTests.cs" Link="RegistryTests.cs" />
11 |     <Compile Include="..\TestApp\SerializerTests.cs" Link="SerializerTests.cs" />
12 |   </ItemGroup>
13 | 
14 |   <ItemGroup>
15 |     <PackageReference Include="Microsoft.Extensions.DependencyModel" Version="3.0.0" />
16 |     <PackageReference Include="Newtonsoft.Json" Version="12.0.3" />
17 |     <PackageReference Include="xunit" Version="2.4.1" />
18 |     <PackageReference Include="xunit.runner.visualstudio" Version="2.4.1">
19 |       <PrivateAssets>all</PrivateAssets>
20 |       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
21 |     </PackageReference>
22 |   </ItemGroup>
23 | 
24 |   <ItemGroup>
25 |     <ProjectReference Include="..\Galador.Reflection\Galador.Reflection.csproj" />
26 |   </ItemGroup>
27 | 
28 |   <ItemGroup>
29 |     <Service Include="{82a7f48d-3b50-4b1e-b82e-3ada8210c358}" />
30 |   </ItemGroup>
31 | 
32 | </Project>


--------------------------------------------------------------------------------
/TestAndroid/MainActivity.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using Android.App;
 3 | using Android.Content;
 4 | using Android.Runtime;
 5 | using Android.Views;
 6 | using Android.Widget;
 7 | using Android.OS;
 8 | using System.Threading.Tasks;
 9 | using TestApp;
10 | 
11 | namespace TestAndroid
12 | {
13 |     [Activity(Label = "TestAndroid", MainLauncher = true, Icon = "@drawable/icon")]
14 |     public class MainActivity : Activity
15 |     {
16 |         protected override void OnCreate(Bundle bundle)
17 |         {
18 |             base.OnCreate(bundle);
19 | 
20 |             var tadapter = new TestAdapter(this, typeof(RegistryTests), typeof(PathTests),typeof(SerializationTests), typeof(StreamTests));
21 | 
22 |             SetContentView(Resource.Layout.Main);
23 |             var list = FindViewById<ListView>(Resource.Id.listView1);
24 |             list.Adapter = tadapter;
25 |             var button = FindViewById<Button>(Resource.Id.MyButton);
26 |             button.Click += async delegate
27 |             {
28 |                 if (tadapter.IsRunning)
29 |                     return;
30 |                 button.Text = "Running Tests...";
31 |                 await tadapter.Run();
32 |                 button.Text = "Start Tests";
33 |             };
34 |         }
35 |     }
36 | }
37 | 
38 | 


--------------------------------------------------------------------------------
/Galador.Reflection/Serialization/ObjectData.cs:
--------------------------------------------------------------------------------
 1 | using Galador.Reflection.Utils;
 2 | using System;
 3 | using System.Collections.Generic;
 4 | using SRS = System.Runtime.Serialization;
 5 | 
 6 | namespace Galador.Reflection.Serialization
 7 | {
 8 |     public class ObjectData
 9 |     {
10 |         internal ObjectData(TypeData type)
11 |         {
12 |             TypeData = type;
13 |         }
14 | 
15 |         public TypeData TypeData { get; }
16 | 
17 |         public SRS.SerializationInfo Info { get; internal set; }
18 |         public string ConverterString { get; internal set; }
19 |         public object SurrogateObject { get; internal set; }
20 |         public MemberList<Member> Members { get; } = new MemberList<Member>();
21 | 
22 |         public IReadOnlyList<object> IList { get; internal set; } = Array.Empty<object>();
23 |         public IReadOnlyList<(object Key, object Value)> IDictionary { get; internal set; } = Array.Empty<(object, object)>();
24 | 
25 |         #region class Member
26 | 
27 |         public class Member : IMember
28 |         {
29 |             public string Name { get; internal set; }
30 |             public TypeData Type { get; internal set; }
31 |             public object Value { get; internal set; }
32 |         }
33 | 
34 |         #endregion
35 |     }
36 | }
37 | 


--------------------------------------------------------------------------------
/Galador.Reflection/Serialization/LostData.cs:
--------------------------------------------------------------------------------
 1 | using Galador.Reflection.Utils;
 2 | using System;
 3 | using System.Collections.Generic;
 4 | using System.Text;
 5 | using SRS = System.Runtime.Serialization;
 6 | 
 7 | namespace Galador.Reflection.Serialization
 8 | {
 9 |     public class LostData
10 |     {
11 |         public LostData(object target)
12 |         {
13 |             Target = target;
14 |         }
15 | 
16 |         public object Target { get; }
17 | 
18 |         public SRS.SerializationInfo SerializationInfo { get; internal set; }
19 |         public MemberList<Member> Members { get; } = new MemberList<Member>();
20 | 
21 |         public IReadOnlyList<object> IList { get; internal set; } = Array.Empty<object>();
22 |         public IReadOnlyList<(object Key, object Value)> IDictionary { get; internal set; } = Array.Empty<(object, object)>();
23 | 
24 |         #region class Member
25 | 
26 |         public class Member : IMember
27 |         {
28 |             internal Member(TypeData.Member target, object value)
29 |             {
30 |                 Name = target.Name;
31 |                 Type = target.Type;
32 |                 Value = value;
33 |             }
34 |             public string Name { get; }
35 |             public TypeData Type { get; }
36 |             public object Value { get; }
37 |         }
38 | 
39 |         #endregion
40 |     }
41 | }
42 | 


--------------------------------------------------------------------------------
/Galador.Reflection/Serialization/SerializationSettings.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using System.ComponentModel;
 4 | using System.Text;
 5 | 
 6 | namespace Galador.Reflection.Serialization
 7 | {
 8 |     /// <summary>
 9 |     /// Settings for the <see cref="ObjectWriter"/> that will affect serialization
10 |     /// </summary>
11 |     public class SerializationSettings
12 |     {
13 |         /// <summary>
14 |         /// Whether to ignore <c>ISerializable</c> interface when serializing. Necessary for compatibility with .NET Core.
15 |         /// </summary>
16 |         /// <remarks>Set to ignore by default since this will make the serialization process less version change tolerant</remarks>
17 |         public bool IgnoreISerializable { get; set; } = true;
18 | 
19 |         /// <summary>
20 |         /// Whether to ignore <see cref="TypeConverter"/> when serializing. If they prove problematic.
21 |         /// </summary>
22 |         /// <remarks>Set to ignore by defaulot since this will make the serialization process less version change tolerant</remarks>
23 |         public bool IgnoreTypeConverter { get; set; } = true;
24 | 
25 | 
26 |         internal int ToFlags()
27 |         {
28 |             int result = 0;
29 |             result |= IgnoreISerializable ? 1 << 1 : 0;
30 |             result |= IgnoreTypeConverter ? 1 << 2 : 0;
31 |             return result;
32 |         }
33 |         internal void FromFlags(int l)
34 |         {
35 |             var flags = (int)l;
36 |             IgnoreISerializable = (flags & (1 << 1)) != 0;
37 |             IgnoreTypeConverter = (flags & (1 << 2)) != 0;
38 |         }
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/TestAndroid/Resources/AboutResources.txt:
--------------------------------------------------------------------------------
 1 | Images, layout descriptions, binary blobs and string dictionaries can be included 
 2 | in your application as resource files.  Various Android APIs are designed to 
 3 | operate on the resource IDs instead of dealing with images, strings or binary blobs 
 4 | directly.
 5 | 
 6 | For example, a sample Android app that contains a user interface layout (main.axml),
 7 | an internationalization string table (strings.xml) and some icons (drawable-XXX/icon.png) 
 8 | would keep its resources in the "Resources" directory of the application:
 9 | 
10 | Resources/
11 |     drawable/
12 |         icon.png
13 | 
14 |     layout/
15 |         main.axml
16 | 
17 |     values/
18 |         strings.xml
19 | 
20 | In order to get the build system to recognize Android resources, set the build action to
21 | "AndroidResource".  The native Android APIs do not operate directly with filenames, but 
22 | instead operate on resource IDs.  When you compile an Android application that uses resources, 
23 | the build system will package the resources for distribution and generate a class called "R" 
24 | (this is an Android convention) that contains the tokens for each one of the resources 
25 | included. For example, for the above Resources layout, this is what the R class would expose:
26 | 
27 | public class R {
28 |     public class drawable {
29 |         public const int icon = 0x123;
30 |     }
31 | 
32 |     public class layout {
33 |         public const int main = 0x456;
34 |     }
35 | 
36 |     public class strings {
37 |         public const int first_string = 0xabc;
38 |         public const int second_string = 0xbcd;
39 |     }
40 | }
41 | 
42 | You would then use R.drawable.icon to reference the drawable/icon.png file, or R.layout.main 
43 | to reference the layout/main.axml file, or R.strings.first_string to reference the first 
44 | string in the dictionary file values/strings.xml.


--------------------------------------------------------------------------------
/Galador.Reflection/Serialization/IO/IPrimitiveReader.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using System.Text;
 4 | 
 5 | namespace Galador.Reflection.Serialization.IO
 6 | {
 7 |     /// <summary>
 8 |     /// An interface that know how to read all primitive type (i.e. all non object <see cref="PrimitiveType"/>) from some underlying storage.
 9 |     /// </summary>
10 |     public interface IPrimitiveReader : IDisposable
11 |     {
12 | #pragma warning disable 1591 // XML Comments
13 |         string ReadString();
14 |         byte[] ReadBytes();
15 |         Guid ReadGuid();
16 |         bool ReadBool();
17 |         char ReadChar();
18 |         byte ReadByte();
19 |         sbyte ReadSByte();
20 |         short ReadInt16();
21 |         ushort ReadUInt16();
22 |         int ReadInt32();
23 |         uint ReadUInt32();
24 |         long ReadInt64();
25 |         ulong ReadUInt64();
26 |         float ReadSingle();
27 |         double ReadDouble();
28 |         decimal ReadDecimal();
29 | #pragma warning restore 1591 // XML Comments
30 | 
31 |         /// <summary>
32 |         /// Reads an <c>long</c> that was written in a more compact format.
33 |         /// </summary>
34 |         /// <returns>The <c>long</c> that was read.</returns>
35 |         long ReadVInt();
36 |         /// <summary>
37 |         /// Reads an <c>ulong</c> that was written in a more compact format.
38 |         /// </summary>
39 |         /// <returns>The <c>ulong</c> that was read.</returns>
40 |         ulong ReadVUInt();
41 |         /// <summary>
42 |         /// Reads an <c>long?</c> that was written in a more compact format.
43 |         /// </summary>
44 |         /// <returns>The <c>long?</c> that was read.</returns>
45 |         long? ReadVNInt();
46 |         /// <summary>
47 |         /// Reads an <c>ulong?</c> that was written in a more compact format.
48 |         /// </summary>
49 |         /// <returns>The <c>ulong?</c> that was read.</returns>
50 |         ulong? ReadVNUInt();
51 |     }
52 | }
53 | 


--------------------------------------------------------------------------------
/Galador.Reflection/Serialization/IO/IPrimitiveWriter.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using System.Text;
 4 | 
 5 | namespace Galador.Reflection.Serialization.IO
 6 | {
 7 |     /// <summary>
 8 |     /// An interface that know how to write all primitive type (i.e. all non object <see cref="PrimitiveType"/>) to some underlying storage.
 9 |     /// </summary>
10 |     public interface IPrimitiveWriter : IDisposable
11 |     {
12 | #pragma warning disable 1591 // XML Comments
13 |         void Write(string value);
14 |         void Write(byte[] value);
15 |         void Write(Guid value);
16 |         void Write(bool value);
17 |         void Write(char value);
18 |         void Write(byte value);
19 |         void Write(sbyte value);
20 |         void Write(short value);
21 |         void Write(ushort value);
22 |         void Write(int value);
23 |         void Write(uint value);
24 |         void Write(long value);
25 |         void Write(ulong value);
26 |         void Write(float value);
27 |         void Write(double value);
28 |         void Write(decimal value);
29 | #pragma warning restore 1591 // XML Comments
30 | 
31 |         /// <summary>
32 |         /// Writes an <c>long</c> in a more compact format.
33 |         /// </summary>
34 |         /// <param name="value">The value to write.</param>
35 |         void WriteVInt(long value);
36 |         /// <summary>
37 |         /// Writes an <c>ulong</c> in a more compact format.
38 |         /// </summary>
39 |         /// <param name="value">The value to write.</param>
40 |         void WriteVInt(ulong value);
41 |         /// <summary>
42 |         /// Writes an <c>long?</c> in a more compact format.
43 |         /// </summary>
44 |         /// <param name="value">The value to write.</param>
45 |         void WriteVInt(long? value);
46 |         /// <summary>
47 |         /// Writes an <c>ulong?</c> in a more compact format.
48 |         /// </summary>
49 |         /// <param name="value">The value to write.</param>
50 |         void WriteVInt(ulong? value);
51 |     }
52 | }
53 | 


--------------------------------------------------------------------------------
/Galador.Reflection/Utils/KnownAssemblies.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using System.Reflection;
 4 | using System.Linq;
 5 | using System.Collections.Concurrent;
 6 | 
 7 | namespace Galador.Reflection.Utils
 8 | {
 9 |     /// <summary>
10 |     /// A utility class to list all loaded assemblies and be notified when new one are loaded.
11 |     /// </summary>
12 |     public static class KnownAssemblies
13 |     {
14 |         static KnownAssemblies()
15 |         {
16 |             var domain = AppDomain.CurrentDomain;
17 | 
18 |             foreach (var ass in domain.GetAssemblies())
19 |                 assemblies[ass.GetName().Name] = ass;
20 | 
21 |             domain.AssemblyLoad += (o, e) =>
22 |             {
23 |                 var ass = e.LoadedAssembly;
24 |                 assemblies[ass.GetName().Name] = ass;
25 |                 AssemblyLoaded?.Invoke(ass);
26 |             };
27 |         }
28 | 
29 |         static ConcurrentDictionary<string, Assembly> assemblies = new ConcurrentDictionary<string, Assembly>();
30 | 
31 | 
32 |         /// <summary>
33 |         /// Enumerate all the currently loaded assembly.
34 |         /// </summary>
35 |         public static IEnumerable<Assembly> Current => assemblies.Values;
36 | 
37 | #pragma warning disable 67
38 |         /// <summary>
39 |         /// Occurs when an assembly is loaded.
40 |         /// </summary>
41 |         public static event Action<Assembly> AssemblyLoaded;
42 | #pragma warning restore 67
43 | 
44 |         /// <summary>
45 |         /// Lookup a type by type name and assembly name.
46 |         /// </summary>
47 |         /// <param name="typeName">Name of the type.</param>
48 |         /// <param name="assemblyName">Name of the assembly.</param>
49 |         /// <returns>A type or null.</returns>
50 |         public static Type GetType(string typeName, string assemblyName)
51 |         {
52 |             if (assemblyName == null)
53 |                 return Type.GetType(typeName);
54 | 
55 |             assemblies.TryGetValue(assemblyName, out var candidate);
56 |             if (candidate != null)
57 |                 return candidate.GetType(typeName);
58 | 
59 |             return null;
60 |         }
61 |     }
62 | }
63 | 


--------------------------------------------------------------------------------
/TestNETCore/Program.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Reflection;
 3 | using TestApp;
 4 | using Xunit;
 5 | using System.Linq;
 6 | 
 7 | namespace TestNETCore
 8 | {
 9 |     public class Program
10 |     {
11 |         //public static void Main(string[] args)
12 |         //{
13 |         //    //KnownTypes.RegisterAssemblies(typeof(ReflectType2).GetTypeInfo().Assembly);
14 |         //    //KnownTypes.RegisterAssemblies(typeof(Program).GetTypeInfo().Assembly);
15 | 
16 |         //    //RunSomeTests();
17 |         //    RunAllTests();
18 | 
19 |         //    Console.WriteLine();
20 |         //    Console.WriteLine("Done.");
21 |         //    Console.ReadLine();
22 |         //}
23 | 
24 |         public static void RunSomeTests()
25 |         {
26 |             //var tReg = new RegistryTests();
27 |             //tReg.Create1();
28 | 
29 |             var tSer = new SerializationTests();
30 |             //tSer.CheckIsSmall();
31 |             //tSer.CheckGeneric();
32 | 
33 |             tSer.CheckComplexClass();
34 |             tSer.CheckSimpleTypes();
35 |         }
36 | 
37 |         public static void RunAllTests()
38 |         {
39 |             RunTests(typeof(RegistryTests), typeof(PathTests), typeof(SerializationTests));
40 |         }
41 |         public static void RunTests(params Type[] testTypes)
42 |         {
43 |             var empty = new object[0];
44 |             foreach (var t in testTypes)
45 |             {
46 |                 Console.WriteLine($"Now Testing {t.FullName}:");
47 |                 Console.WriteLine("==================");
48 |                 var methods = from m in t.GetTypeInfo().GetMethods()
49 |                               let fa = m.GetCustomAttribute<FactAttribute>()
50 |                               where fa != null
51 |                               select m;
52 |                 var tc = Activator.CreateInstance(t);
53 |                 foreach (var m in methods)
54 |                 {
55 |                     Console.Write($"\tTest {m.Name}....");
56 |                     try
57 |                     {
58 |                         m.Invoke(tc, empty);
59 |                         Console.WriteLine("\tSuccess");
60 |                     }
61 |                     catch (Exception ex)
62 |                     {
63 |                         var exb = ex.GetBaseException();
64 |                         Console.WriteLine($"\tError ({exb.Message ?? exb.GetType().Name})");
65 |                     }
66 |                 }
67 |                 Console.WriteLine();
68 |             }
69 |         }
70 |     }
71 | }


--------------------------------------------------------------------------------
/.gitattributes:
--------------------------------------------------------------------------------
 1 | ###############################################################################
 2 | # Set default behavior to automatically normalize line endings.
 3 | ###############################################################################
 4 | * text=auto
 5 | 
 6 | ###############################################################################
 7 | # Set default behavior for command prompt diff.
 8 | #
 9 | # This is need for earlier builds of msysgit that does not have it on by
10 | # default for csharp files.
11 | # Note: This is only used by command line
12 | ###############################################################################
13 | #*.cs     diff=csharp
14 | 
15 | ###############################################################################
16 | # Set the merge driver for project and solution files
17 | #
18 | # Merging from the command prompt will add diff markers to the files if there
19 | # are conflicts (Merging from VS is not affected by the settings below, in VS
20 | # the diff markers are never inserted). Diff markers may cause the following 
21 | # file extensions to fail to load in VS. An alternative would be to treat
22 | # these files as binary and thus will always conflict and require user
23 | # intervention with every merge. To do so, just uncomment the entries below
24 | ###############################################################################
25 | #*.sln       merge=binary
26 | #*.csproj    merge=binary
27 | #*.vbproj    merge=binary
28 | #*.vcxproj   merge=binary
29 | #*.vcproj    merge=binary
30 | #*.dbproj    merge=binary
31 | #*.fsproj    merge=binary
32 | #*.lsproj    merge=binary
33 | #*.wixproj   merge=binary
34 | #*.modelproj merge=binary
35 | #*.sqlproj   merge=binary
36 | #*.wwaproj   merge=binary
37 | 
38 | ###############################################################################
39 | # behavior for image files
40 | #
41 | # image files are treated as binary by default.
42 | ###############################################################################
43 | #*.jpg   binary
44 | #*.png   binary
45 | #*.gif   binary
46 | 
47 | ###############################################################################
48 | # diff behavior for common document formats
49 | # 
50 | # Convert binary document formats to text before diffing them. This feature
51 | # is only available from the command line. Turn it on by uncommenting the 
52 | # entries below.
53 | ###############################################################################
54 | #*.doc   diff=astextplain
55 | #*.DOC   diff=astextplain
56 | #*.docx  diff=astextplain
57 | #*.DOCX  diff=astextplain
58 | #*.dot   diff=astextplain
59 | #*.DOT   diff=astextplain
60 | #*.pdf   diff=astextplain
61 | #*.PDF   diff=astextplain
62 | #*.rtf   diff=astextplain
63 | #*.RTF   diff=astextplain
64 | 


--------------------------------------------------------------------------------
/Galador.Reflection/Utils/MemberList.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections;
 3 | using System.Collections.Generic;
 4 | using System.Text;
 5 | 
 6 | namespace Galador.Reflection.Utils
 7 | {
 8 |     /// <summary>
 9 |     /// Object which have a name and are used with <see cref="MemberList{T}"/>.
10 |     /// </summary>
11 |     public interface IMember
12 |     {
13 |         /// <summary>
14 |         /// The name of this member. Use as an index in <see cref="MemberList{T}"/>.
15 |         /// </summary>
16 |         string Name { get; }
17 |     }
18 | 
19 |     /// <summary>
20 |     /// Specialized list of <typeparamref name="T"/> which must be <see cref="IMember"/>.
21 |     /// Index them by both int index but also name.
22 |     /// </summary>
23 |     public class MemberList<T> : IReadOnlyList<T>, IEnumerable<T>
24 |         where T : IMember
25 |     {
26 |         List<T> list = new List<T>();
27 |         Dictionary<string, T> dict = new Dictionary<string, T>();
28 | 
29 |         internal MemberList()
30 |         {
31 |         }
32 | 
33 |         internal void Add(T m)
34 |         {
35 |             if (dict.ContainsKey(m.Name))
36 |                 throw new ArgumentException();
37 |             list.Add(m);
38 |             dict[m.Name] = m;
39 |         }
40 | 
41 |         /// <summary>
42 |         /// Gets the <typeparamref name="T"/> with the given name.
43 |         /// </summary>
44 |         /// <param name="name">Name of the member.</param>
45 |         /// <returns>Return the member with name, or null.</returns>
46 |         public T this[string name]
47 |         {
48 |             get
49 |             {
50 |                 T m;
51 |                 dict.TryGetValue(name, out m);
52 |                 return m;
53 |             }
54 |         }
55 |         /// <summary>
56 |         /// Gets the <typeparamref name="T"/> at the specified index.
57 |         /// </summary>
58 |         public T this[int index] { get { return list[index]; } }
59 | 
60 |         /// <summary>
61 |         /// Number of members or item.
62 |         /// </summary>
63 |         public int Count { get { return list.Count; } }
64 | 
65 |         /// <summary>
66 |         /// All the member's names.
67 |         /// </summary>
68 |         public IEnumerable<string> MemberNames => dict.Keys;
69 | 
70 |         /// <summary>
71 |         /// Whether a member with such a name exists.
72 |         /// </summary>
73 |         /// <param name="name">The member's name.</param>
74 |         /// <returns>Whether there is such a member.</returns>
75 |         public bool Contains(string name) { return dict.ContainsKey(name); }
76 | 
77 |         /// <summary>
78 |         /// Enumerate the members.
79 |         /// </summary>
80 |         public IEnumerator<T> GetEnumerator() { return list.GetEnumerator(); }
81 | 
82 |         IEnumerator IEnumerable.GetEnumerator() { return list.GetEnumerator(); }
83 |     }
84 | }
85 | 


--------------------------------------------------------------------------------
/TestApp/StreamTests.cs:
--------------------------------------------------------------------------------
 1 | using Galador.Reflection.Utils;
 2 | using System;
 3 | using System.Collections.Generic;
 4 | using System.IO;
 5 | using System.Linq;
 6 | using System.Text;
 7 | using System.Threading.Tasks;
 8 | using Xunit;
 9 | 
10 | namespace TestApp
11 | {
12 |     public class StreamTests
13 |     {
14 |         [Fact]
15 |         public void VariableLongStream()
16 |         {
17 |             var ms = new MemoryStream();
18 | 
19 |             var ul = 0x78ea0ul;
20 |             int len = ms.WriteVUInt(ul);
21 |             Assert.Equal(len, ms.Length);
22 |             ms.Position = 0;
23 |             var ul2 = ms.ReadVUInt();
24 |             Assert.Equal(ul, ul2);
25 |             Assert.True(ms.Length == 3);
26 | 
27 |             ul = 0xFFFFFFFFFFFFFFFFul;
28 |             ms.Position = 0;
29 |             len = ms.WriteVNUInt((ulong?)ul);
30 |             Assert.Equal(len, ms.Length);
31 |             ms.Position = 0;
32 |             ul2 = ms.ReadVUInt();
33 |             Assert.Equal(ul, ul2);
34 |         }
35 | 
36 |         [Theory]
37 |         [InlineData(0x3Ful)]
38 |         [InlineData(0x40ul)]
39 |         [InlineData(0x7Ful)]
40 |         [InlineData(0x80ul)]
41 |         [InlineData(0xFFFFFFFFFFFFFFFFul)]
42 |         [InlineData(0ul)]
43 |         [InlineData(null)]
44 |         public void EdgeValueNUint(ulong? ul)
45 |         {
46 |             var ms = new MemoryStream();
47 |             int len = ms.WriteVNUInt(ul);
48 |             Assert.Equal(len, ms.Length);
49 |             ms.Position = 0;
50 |             var ul2 = ms.ReadVNUInt();
51 |             Assert.Equal(ul, ul2);
52 |         }
53 | 
54 |         [Theory]
55 |         [InlineData(0x7Ful)]
56 |         [InlineData(0x80ul)]
57 |         [InlineData(0xFFFFFFFFFFFFFFFFul)]
58 |         [InlineData(0)]
59 |         public void EdgeValueUint(ulong ul)
60 |         {
61 |             var ms = new MemoryStream();
62 |             int len = ms.WriteVUInt(ul);
63 |             Assert.Equal(len, ms.Length);
64 |             ms.Position = 0;
65 |             var ul2 = ms.ReadVUInt();
66 |             Assert.Equal(ul, ul2);
67 |         }
68 | 
69 |         [Theory]
70 |         [InlineData(0xFFFFL)]
71 |         [InlineData(-0xFFFFL)]
72 |         [InlineData(null)]
73 |         public void SomeValuesNInt(long? l)
74 |         {
75 |             var ms = new MemoryStream();
76 |             int len = ms.WriteVNInt(l);
77 |             ms.Position = 0;
78 |             var l2 = ms.ReadVNInt();
79 |             Assert.Equal(l, l2);
80 |         }
81 | 
82 |         [Theory]
83 |         [InlineData(0xFFFF)]
84 |         [InlineData(-0xFFFF)]
85 |         [InlineData(0)]
86 |         public void SomeValuesInt(long l)
87 |         {
88 |             var ms = new MemoryStream();
89 |             int len = ms.WriteVInt(l);
90 |             ms.Position = 0;
91 |             var l2 = ms.ReadVInt();
92 |             Assert.Equal(l, l2);
93 |         }
94 |     }
95 | }
96 | 


--------------------------------------------------------------------------------
/Galador.Reflection/Utils/CollectionEx.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using System.Linq;
 4 | using System.Text;
 5 | using System.Threading.Tasks;
 6 | 
 7 | namespace Galador.Reflection.Utils
 8 | {
 9 |     /// <summary>
10 |     /// Static utility classes for collection
11 |     /// </summary>
12 |     static class CollectionEx
13 |     {
14 |         public static byte[] SubArray(this byte[] data, int start, int count)
15 |         {
16 |             var res = new byte[count];
17 |             Buffer.BlockCopy(data, start, res, 0, count);
18 |             return res;
19 |         }
20 |         public static byte[] SubArray(this byte[] data, int start) { return SubArray(data, start, data.Length - start); }
21 | 
22 |         public static IEnumerable<T> AsEnumerable<T>(this T item, Func<T, T> getNext)
23 |             where T: class
24 |         {
25 |             var tmp = item;
26 |             while (tmp != null)
27 |             {
28 |                 yield return tmp;
29 |                 tmp = getNext(tmp);
30 |             }
31 |         }
32 | 
33 |         /// <summary>
34 |         /// Enumerate an IEnumerable and perform an action on each of them. Return the enumerable.
35 |         /// </summary>
36 |         public static IEnumerable<T> ForEach<T>(this IEnumerable<T> collection, Action<T> action)
37 |         {
38 |             // WARNING do NOT use yield for that
39 |             if (collection != null)
40 |                 foreach (var item in collection)
41 |                     action(item);
42 |             return collection;
43 |         }
44 | 
45 |         public static List<T> Remove<T>(this ICollection<T> col, Predicate<T> match)
46 |         {
47 |             var removed = new List<T>();
48 |             if (col is IList<T>)
49 |             {
50 |                 var list = (IList<T>)col;
51 |                 for (int i = list.Count - 1; i >= 0; i--)
52 |                 {
53 |                     var item = list[i];
54 |                     if (match(item))
55 |                     {
56 |                         list.RemoveAt(i);
57 |                         removed.Add(item);
58 |                     }
59 |                 }
60 |             }
61 |             else
62 |             {
63 |                 var list = col.Where(x => match(x)).ToList(); // save them first, removing as we go might be problematic
64 |                 foreach (var item in list)
65 |                 {
66 |                     col.Remove(item);
67 |                     removed.Add(item);
68 |                 }
69 |             }
70 |             return removed;
71 |         }
72 | 
73 |         public static IEnumerable<T> Remove<T>(this ICollection<T> col, params T[] items)
74 |         {
75 |             return col.Remove((IEnumerable<T>)items);
76 |         }
77 |         public static IEnumerable<T> Remove<T>(this ICollection<T> col, IEnumerable<T> items)
78 |         {
79 |             var removed = new List<T>();
80 |             foreach (var item in items)
81 |             {
82 |                 if (col.Remove(item))
83 |                     removed.Add(item);
84 |             }
85 |             return removed;
86 |         }
87 |     }
88 | }
89 | 


--------------------------------------------------------------------------------
/SHBDocumentation.shfbproj:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
 3 |   <PropertyGroup>
 4 |     <!-- The configuration and platform will be used to determine which assemblies to include from solution and
 5 | 				 project documentation sources -->
 6 |     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
 7 |     <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
 8 |     <SchemaVersion>2.0</SchemaVersion>
 9 |     <ProjectGuid>{a4713b1c-5ec9-4dea-b897-dbfbe7c96014}</ProjectGuid>
10 |     <SHFBSchemaVersion>2015.6.5.0</SHFBSchemaVersion>
11 |     <!-- AssemblyName, Name, and RootNamespace are not used by SHFB but Visual Studio adds them anyway -->
12 |     <AssemblyName>Documentation</AssemblyName>
13 |     <RootNamespace>Documentation</RootNamespace>
14 |     <Name>Documentation</Name>
15 |     <!-- SHFB properties -->
16 |     <FrameworkVersion>.NET Framework 4.5</FrameworkVersion>
17 |     <OutputPath>.\Help\</OutputPath>
18 |     <HtmlHelpName>Galador.Reflection</HtmlHelpName>
19 |     <Language>en-US</Language>
20 |     <HelpFileVersion>1.0.0.0</HelpFileVersion>
21 |     <MaximumGroupParts>2</MaximumGroupParts>
22 |     <NamespaceGrouping>False</NamespaceGrouping>
23 |     <SyntaxFilters>Standard</SyntaxFilters>
24 |     <SdkLinkTarget>Blank</SdkLinkTarget>
25 |     <RootNamespaceContainer>False</RootNamespaceContainer>
26 |     <PresentationStyle>VS2013</PresentationStyle>
27 |     <Preliminary>False</Preliminary>
28 |     <NamingMethod>Guid</NamingMethod>
29 |     <HelpTitle>Galador.Reflection Class Library Documentation</HelpTitle>
30 |     <ContentPlacement>AboveNamespaces</ContentPlacement>
31 |     <ProjectSummary>Latest source to be found at: &amp;lt%3bbr/&amp;gt%3b
32 | &amp;lt%3ba href=&amp;quot%3bhttps://github.com/superlloyd/Galador.Reflection&amp;gt%3bhttps://github.com/superlloyd/Galador.Reflection&amp;lt%3b/a&amp;gt%3b</ProjectSummary>
33 |     <DocumentationSources>
34 |       <DocumentationSource sourceFile="Galador.Reflection.NET\bin\Release\Galador.Reflection.dll" />
35 | <DocumentationSource sourceFile="Galador.Reflection.NET\bin\Release\Galador.Reflection.xml" /></DocumentationSources>
36 |   </PropertyGroup>
37 |   <!-- There are no properties for these groups.  AnyCPU needs to appear in order for Visual Studio to perform
38 | 			 the build.  The others are optional common platform types that may appear. -->
39 |   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
40 |   </PropertyGroup>
41 |   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
42 |   </PropertyGroup>
43 |   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' ">
44 |   </PropertyGroup>
45 |   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
46 |   </PropertyGroup>
47 |   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x64' ">
48 |   </PropertyGroup>
49 |   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x64' ">
50 |   </PropertyGroup>
51 |   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|Win32' ">
52 |   </PropertyGroup>
53 |   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|Win32' ">
54 |   </PropertyGroup>
55 |   <!-- Import the SHFB build targets -->
56 |   <Import Project="$(SHFBROOT)\SandcastleHelpFileBuilder.targets" />
57 |   <!-- The pre-build and post-build event properties must appear *after* the targets file import in order to be
58 | 			 evaluated correctly. -->
59 |   <PropertyGroup>
60 |     <PreBuildEvent>
61 |     </PreBuildEvent>
62 |     <PostBuildEvent>
63 |     </PostBuildEvent>
64 |     <RunPostBuildEvent>OnBuildSuccess</RunPostBuildEvent>
65 |   </PropertyGroup>
66 |   <ItemGroup>
67 |     <ProjectReference Include="Galador.Reflection.NET\Galador.Reflection.NET.csproj">
68 |       <Name>Galador.Reflection</Name>
69 |       <Project>{419F3792-2CAC-47FF-ACD6-483D6BBFE846}</Project>
70 |     </ProjectReference>
71 |   </ItemGroup>
72 | </Project>


--------------------------------------------------------------------------------
/Galador.Reflection/Utils/FastMethod.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using System.Reflection;
 4 | using System.Text;
 5 | 
 6 | namespace Galador.Reflection.Utils
 7 | {
 8 |     /// <summary>
 9 |     /// Wrap a <see cref="MethodBase"/> and provide fast call with System.Emit when available,
10 |     /// or fallback to normal reflection otherwise.
11 |     /// </summary>
12 |     public sealed class FastMethod
13 |     {
14 |         ParameterInfo[] parameters;
15 |         MethodBase method;
16 |         MethodHandler fastMethod;
17 | 
18 |         /// <summary>
19 |         /// Name of the method.
20 |         /// </summary>
21 |         public string Name { get { return method.Name; } }
22 | 
23 |         /// <summary>
24 |         /// Underlying method
25 |         /// </summary>
26 |         public MethodBase Method { get { return method; } }
27 | 
28 |         /// <summary>
29 |         /// Return the method's parameters.
30 |         /// </summary>
31 |         public IReadOnlyList<ParameterInfo> Parameters { get { return parameters; } }
32 | 
33 |         /// <summary>
34 |         /// Construct a new <see cref="FastMethod"/> associated with an existing method.
35 |         /// </summary>
36 |         /// <param name="method">The method.</param>
37 |         /// <remarks>the constructor is kept private as the FastMethod constructor itself is expensive and instance MUST be cached for performance improvement</remarks>
38 |         internal FastMethod(MethodBase method)
39 |         {
40 |             parameters = method.GetParameters();
41 |             this.method = method;
42 |             fastMethod = EmitHelper.CreateMethodHandler(method);
43 |         }
44 | 
45 |         /// <summary>
46 |         /// Create and return cached <see cref="FastMethod"/> from any <see cref="MethodBase"/>.
47 |         /// </summary>
48 |         public static FastMethod GetMethod(MethodBase method)
49 |         {
50 |             if (method == null)
51 |                 return null;
52 |             lock (allmethods)
53 |             {
54 |                 FastMethod result;
55 |                 if (allmethods.TryGetValue(method, out result))
56 |                     return result;
57 |                 result = new Utils.FastMethod(method);
58 |                 allmethods[method] = result;
59 |                 return result;
60 |             }
61 |         }
62 |         static Dictionary<MethodBase, FastMethod> allmethods = new Dictionary<MethodBase, FastMethod>();
63 | 
64 |         internal FastMethod(ConstructorInfo method, bool doNotCreate = false)
65 |         {
66 |             parameters = method.GetParameters();
67 |             this.method = method;
68 |             fastMethod = EmitHelper.CreateMethodHandler(method, doNotCreate);
69 |         }
70 | 
71 |         /// <summary>
72 |         /// Call the associated method.
73 |         /// </summary>
74 |         /// <param name="target">The instance to use to call. For constructor and static method, pass null.</param>
75 |         /// <param name="args">The arguments of the method call. Argument with default value can be omitted.</param>
76 |         /// <returns>The return of the method, if any.</returns>
77 |         public object Invoke(object target, params object[] args)
78 |         {
79 |             if (args == null)
80 |                 args = Array.Empty<object>();
81 |             if (args.Length < parameters.Length)
82 |             {
83 |                 for (int i = args.Length; i < parameters.Length; i++)
84 |                 {
85 |                     if (!parameters[i].HasDefaultValue)
86 |                         throw new ArgumentException($"Method has {parameters.Length} parameters, only {args.Length} passed, argument {i} do NOT have a default value");
87 |                 }
88 |                 var args2 = new object[parameters.Length];
89 |                 for (int i = 0; i < args.Length; i++)
90 |                     args2[i] = args[i];
91 |                 for (int i = args.Length; i < parameters.Length; i++)
92 |                     args2[i] = parameters[i].DefaultValue;
93 |                 args = args2;
94 |             }
95 |             return fastMethod(target, args);
96 |         }
97 |     }
98 | }
99 | 


--------------------------------------------------------------------------------
/Galador.Reflection.sln:
--------------------------------------------------------------------------------
 1 | 
 2 | Microsoft Visual Studio Solution File, Format Version 12.00
 3 | # Visual Studio Version 17
 4 | VisualStudioVersion = 17.0.31717.71
 5 | MinimumVisualStudioVersion = 10.0.40219.1
 6 | Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "TestApp", "TestApp\TestApp.csproj", "{321250AB-D521-4495-A614-62385E8B5407}"
 7 | EndProject
 8 | Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{0BC3D4CC-A0C7-4552-89BE-2B1612F82C5D}"
 9 | 	ProjectSection(SolutionItems) = preProject
10 | 		build.bat = build.bat
11 | 		LICENSE.txt = LICENSE.txt
12 | 		README.md = README.md
13 | 		registry.md = registry.md
14 | 		serializer.md = serializer.md
15 | 	EndProjectSection
16 | EndProject
17 | Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Galador.Reflection", "Galador.Reflection\Galador.Reflection.csproj", "{B7D89600-3529-498F-B11E-F9790846B442}"
18 | EndProject
19 | Global
20 | 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
21 | 		Debug|Any CPU = Debug|Any CPU
22 | 		Debug|ARM = Debug|ARM
23 | 		Debug|x64 = Debug|x64
24 | 		Debug|x86 = Debug|x86
25 | 		Release|Any CPU = Release|Any CPU
26 | 		Release|ARM = Release|ARM
27 | 		Release|x64 = Release|x64
28 | 		Release|x86 = Release|x86
29 | 	EndGlobalSection
30 | 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
31 | 		{321250AB-D521-4495-A614-62385E8B5407}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
32 | 		{321250AB-D521-4495-A614-62385E8B5407}.Debug|Any CPU.Build.0 = Debug|Any CPU
33 | 		{321250AB-D521-4495-A614-62385E8B5407}.Debug|ARM.ActiveCfg = Debug|Any CPU
34 | 		{321250AB-D521-4495-A614-62385E8B5407}.Debug|ARM.Build.0 = Debug|Any CPU
35 | 		{321250AB-D521-4495-A614-62385E8B5407}.Debug|x64.ActiveCfg = Debug|Any CPU
36 | 		{321250AB-D521-4495-A614-62385E8B5407}.Debug|x64.Build.0 = Debug|Any CPU
37 | 		{321250AB-D521-4495-A614-62385E8B5407}.Debug|x86.ActiveCfg = Debug|Any CPU
38 | 		{321250AB-D521-4495-A614-62385E8B5407}.Debug|x86.Build.0 = Debug|Any CPU
39 | 		{321250AB-D521-4495-A614-62385E8B5407}.Release|Any CPU.ActiveCfg = Release|Any CPU
40 | 		{321250AB-D521-4495-A614-62385E8B5407}.Release|Any CPU.Build.0 = Release|Any CPU
41 | 		{321250AB-D521-4495-A614-62385E8B5407}.Release|ARM.ActiveCfg = Release|Any CPU
42 | 		{321250AB-D521-4495-A614-62385E8B5407}.Release|ARM.Build.0 = Release|Any CPU
43 | 		{321250AB-D521-4495-A614-62385E8B5407}.Release|x64.ActiveCfg = Release|Any CPU
44 | 		{321250AB-D521-4495-A614-62385E8B5407}.Release|x64.Build.0 = Release|Any CPU
45 | 		{321250AB-D521-4495-A614-62385E8B5407}.Release|x86.ActiveCfg = Release|Any CPU
46 | 		{321250AB-D521-4495-A614-62385E8B5407}.Release|x86.Build.0 = Release|Any CPU
47 | 		{B7D89600-3529-498F-B11E-F9790846B442}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
48 | 		{B7D89600-3529-498F-B11E-F9790846B442}.Debug|Any CPU.Build.0 = Debug|Any CPU
49 | 		{B7D89600-3529-498F-B11E-F9790846B442}.Debug|ARM.ActiveCfg = Debug|Any CPU
50 | 		{B7D89600-3529-498F-B11E-F9790846B442}.Debug|ARM.Build.0 = Debug|Any CPU
51 | 		{B7D89600-3529-498F-B11E-F9790846B442}.Debug|x64.ActiveCfg = Debug|Any CPU
52 | 		{B7D89600-3529-498F-B11E-F9790846B442}.Debug|x64.Build.0 = Debug|Any CPU
53 | 		{B7D89600-3529-498F-B11E-F9790846B442}.Debug|x86.ActiveCfg = Debug|Any CPU
54 | 		{B7D89600-3529-498F-B11E-F9790846B442}.Debug|x86.Build.0 = Debug|Any CPU
55 | 		{B7D89600-3529-498F-B11E-F9790846B442}.Release|Any CPU.ActiveCfg = Release|Any CPU
56 | 		{B7D89600-3529-498F-B11E-F9790846B442}.Release|Any CPU.Build.0 = Release|Any CPU
57 | 		{B7D89600-3529-498F-B11E-F9790846B442}.Release|ARM.ActiveCfg = Release|Any CPU
58 | 		{B7D89600-3529-498F-B11E-F9790846B442}.Release|ARM.Build.0 = Release|Any CPU
59 | 		{B7D89600-3529-498F-B11E-F9790846B442}.Release|x64.ActiveCfg = Release|Any CPU
60 | 		{B7D89600-3529-498F-B11E-F9790846B442}.Release|x64.Build.0 = Release|Any CPU
61 | 		{B7D89600-3529-498F-B11E-F9790846B442}.Release|x86.ActiveCfg = Release|Any CPU
62 | 		{B7D89600-3529-498F-B11E-F9790846B442}.Release|x86.Build.0 = Release|Any CPU
63 | 	EndGlobalSection
64 | 	GlobalSection(SolutionProperties) = preSolution
65 | 		HideSolutionNode = FALSE
66 | 	EndGlobalSection
67 | 	GlobalSection(ExtensibilityGlobals) = postSolution
68 | 		SolutionGuid = {4CF92EB4-781A-4FA8-A816-458BE431CA44}
69 | 	EndGlobalSection
70 | EndGlobal
71 | 


--------------------------------------------------------------------------------
/TestApp/RegistryTests.cs:
--------------------------------------------------------------------------------
  1 | using Galador.Reflection;
  2 | using System;
  3 | using System.Collections.Generic;
  4 | using System.Linq;
  5 | using System.Reflection;
  6 | using System.Text;
  7 | using System.Threading.Tasks;
  8 | using Xunit;
  9 | 
 10 | namespace TestApp
 11 | {
 12 |     public class RegistryTests
 13 |     {
 14 |         public class Disp1 : IDisposable { void IDisposable.Dispose() { } }
 15 |         public class Disp2 : IDisposable { void IDisposable.Dispose() { } }
 16 |         public class Disp3 : IDisposable { void IDisposable.Dispose() { } }
 17 | 
 18 |         class HasDispose
 19 |         {
 20 |             [Import]
 21 |             public IDisposable[] Disposables { get; set; }
 22 |             [Import]
 23 |             public List<IDisposable> DisposableList { get; } = new List<IDisposable>();
 24 |         }
 25 |         
 26 |         [Fact]
 27 |         public void CheckListInjection()
 28 |         {
 29 |             var reg = new Registry();
 30 |             reg.Register(typeof(Disp1), typeof(Disp2), typeof(Disp3));
 31 |             var h = reg.Resolve<HasDispose>();
 32 |             Assert.True(h.Disposables.Length > 3);
 33 |             Assert.Equal(h.Disposables.Length, h.DisposableList.Count);
 34 |             for (int i = 0; i < h.Disposables.Length; i++)
 35 |                 Assert.Equal(h.Disposables[i], h.DisposableList[i]);
 36 |         }
 37 | 
 38 |         interface IService1 { }
 39 |         [Export]
 40 |         class ServiceImpl1 : IService1
 41 |         {
 42 |             [Import]
 43 |             public Service2 Service2 { get; set; }
 44 |         }
 45 |         class Service2
 46 |         {
 47 |             [Import]
 48 |             public ServiceImpl1 Service1 { get; set; }
 49 |             [Import]
 50 |             public Service3 Service3 { get; set; }
 51 |         }
 52 |         class Service3
 53 |         {
 54 |             public Service3(IService1 svc)
 55 |             {
 56 |                 Service1 = svc;
 57 |             }
 58 |             public IService1 Service1 { get; set; }
 59 |         }
 60 | 
 61 |         [Fact]
 62 |         public void TestInjection()
 63 |         {
 64 |             var reg = new Registry();
 65 |             reg.Register<ServiceImpl1>();
 66 |             var s2 = reg.Resolve<Service2>();
 67 |             Assert.NotNull(s2.Service1);
 68 |             Assert.NotNull(s2.Service3);
 69 |             Assert.NotNull(s2.Service3.Service1);
 70 |             Assert.Equal(s2.Service3.Service1, s2.Service1);
 71 |             Assert.Equal(s2.Service1.Service2, s2);
 72 |         }
 73 | 
 74 |         interface IFoo
 75 |         {
 76 |             Too MyToo { get; }
 77 |         }
 78 |         interface IBar
 79 |         {
 80 |         }
 81 |         [Export]
 82 |         class Bar1 : IBar { }
 83 |         class Bar2 : IBar { }
 84 |         class FooImpl : IFoo
 85 |         {
 86 |             public FooImpl(Too tt)
 87 |             {
 88 | 
 89 |             }
 90 |             [ImportAttribute]
 91 |             public Too MyToo { get; set; }
 92 |             [ImportAttribute]
 93 |             public IBar[] Bars { get; set; }
 94 |         }
 95 |         class Too
 96 |         {
 97 | 
 98 |         }
 99 | 
100 |         [Fact]
101 |         public void Create1()
102 |         {
103 |             var t0 = new FooImpl(null);
104 | 
105 |             var r = new Registry();
106 |             r.Register<FooImpl>();
107 |             r.Register<Bar1>();
108 |             r.Register<Bar2>();
109 | 
110 |             var o = r.ResolveAll<IFoo>().ToList();
111 |             Assert.Single(o);
112 |             Assert.NotNull(o[0]);
113 |             var oo = o[0];
114 |             Assert.NotNull(oo.MyToo);
115 |             Assert.True(oo is FooImpl);
116 |             var fi = (FooImpl)oo;
117 |             Assert.Equal(2, fi.Bars.Length);
118 |             Assert.True(fi.Bars.First(x => x is Bar1) != null);
119 |             Assert.True(fi.Bars.First(x => x is Bar2) != null);
120 |         }
121 | 
122 |         [Fact]
123 |         public void Create2()
124 |         {
125 |             var t0 = new FooImpl(null);
126 | 
127 |             var r = new Registry();
128 |             r.RegisterAssemblies<ExportAttribute>();
129 | 
130 |             var o = r.ResolveAll<IBar>().ToList();
131 |             Assert.Single(o);
132 |         }
133 |     }
134 | }
135 | 


--------------------------------------------------------------------------------
/TestApp/PathTests.cs:
--------------------------------------------------------------------------------
  1 | using Galador.Reflection;
  2 | using System;
  3 | using System.Collections.Generic;
  4 | using System.ComponentModel;
  5 | using System.Linq;
  6 | using System.Runtime.CompilerServices;
  7 | using System.Text;
  8 | using System.Threading.Tasks;
  9 | using Xunit;
 10 | 
 11 | namespace TestApp
 12 | {
 13 |     public class PathTests
 14 |     {
 15 |         class Model : INotifyPropertyChanged
 16 |         {
 17 |             #region Name
 18 | 
 19 |             public string Name
 20 |             {
 21 |                 get { return mName; }
 22 |                 set
 23 |                 {
 24 |                     if (value == mName)
 25 |                         return;
 26 | 
 27 |                     mName = value;
 28 |                     OnPropertyChanged(nameof(Name));
 29 |                 }
 30 |             }
 31 |             string mName;
 32 | 
 33 |             #endregion
 34 | 
 35 |             #region Other
 36 | 
 37 |             public Model Other
 38 |             {
 39 |                 get { return mOther; }
 40 |                 set
 41 |                 {
 42 |                     if (value == mOther)
 43 |                         return;
 44 | 
 45 |                     mOther = value;
 46 |                     OnPropertyChanged(nameof(Other));
 47 |                 }
 48 |             }
 49 |             Model mOther;
 50 | 
 51 |             #endregion
 52 | 
 53 |             void OnPropertyChanged([CallerMemberName]string pName = null)
 54 |             {
 55 |                 PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(pName));
 56 |             }
 57 |             public event PropertyChangedEventHandler PropertyChanged;
 58 |         }
 59 | 
 60 |         [Fact]
 61 |         public void PathWorks()
 62 |         {
 63 |             var m = new Model();
 64 |             var values = new List<string>();
 65 | 
 66 |             var p = PropertyPath.Watch(m, x => x.Other.Name, x => {
 67 |                 values.Add(x);
 68 |             });
 69 | 
 70 |             m.Name = "Albert";
 71 |             m.Other = m;
 72 |             m.Other = new Model { Name = "Fubar" };
 73 |             m.Other.Name = "ugh?";
 74 |             m.Other = null;
 75 | 
 76 |             Assert.Equal(4, values.Count);
 77 |             Assert.Equal("Albert", values[0]);
 78 |             Assert.Equal("Fubar", values[1]);
 79 |             Assert.Equal("ugh?", values[2]);
 80 |             Assert.Null(values[3]);
 81 | 
 82 | 
 83 |             GC.KeepAlive(m);
 84 |         }
 85 | 
 86 | 
 87 |         [Fact]
 88 |         public void WeakRefWorks()
 89 |         {
 90 |             var m = new Model();
 91 |             var refCont = new int[1];
 92 |             ForgetfulTrack(m, refCont);
 93 | 
 94 | 
 95 |             m.Name = "Albert";
 96 |             m.Other = m;
 97 |             m.Other = new Model { Name = "Fubar" };
 98 | 
 99 |             GC.Collect();
100 |             m.Other.Name = "ugh?";
101 |             m.Other = null;
102 | 
103 |             Assert.Equal(2, refCont[0]);
104 |         }
105 |         void ForgetfulTrack(Model m, int[] counter)
106 |         {
107 |             PropertyPath.Watch(m, x => x.Other.Name, x => {
108 |                 counter[0]++;
109 |             });
110 |         }
111 | 
112 | 
113 | 
114 |         [Fact]
115 |         public void BindingWorks()
116 |         {
117 |             var m = new Model()
118 |             {
119 |                 Other = new Model(),
120 |             };
121 |             var m0 = new Model()
122 |             {
123 |                 Other = new Model(),
124 |             };
125 |             var b = PropertyBinding.Create(() => m.Name, () => m0.Name);
126 | 
127 |             m.Name = "Albert";
128 |             Assert.Equal(m.Name, m0.Name);
129 |             m.Name = "Einstein";
130 |             Assert.Equal(m.Name, m0.Name);
131 | 
132 |             var m2 = new Model();
133 |             var b2 = PropertyBinding.Create(() => m.Name, () => m2.Name);
134 | 
135 |             Assert.Equal(m.Name, m2.Name);
136 |             m.Name = "Landau";
137 |             Assert.Equal(m.Name, m2.Name);
138 | 
139 |             b.Dispose();
140 |             m.Name = "fufuf";
141 |             Assert.NotEqual(m.Name, m0.Name);
142 | 
143 |             GC.KeepAlive(m);
144 |         }
145 | 
146 | 
147 |         [Fact]
148 |         public void WeakRefBindingWorks()
149 |         {
150 |             var m = new Model();
151 |             var m2 = new Model();
152 |             ForgetfulBind(m, m2);
153 | 
154 |             var s1 = m.Name = "Albert";
155 |             Assert.Equal(s1, m2.Name);
156 | 
157 |             GC.Collect();
158 |             m.Name = "ugh?";
159 |             m.Other = null;
160 | 
161 |             Assert.Equal(s1, m2.Name);
162 |         }
163 |         void ForgetfulBind(Model m1, Model m2)
164 |         {
165 |             PropertyBinding.Create(() => m1.Name, () => m2.Name);
166 |         }
167 |     }
168 | }
169 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
  1 | ## Ignore Visual Studio temporary files, build results, and
  2 | ## files generated by popular Visual Studio add-ons.
  3 | 
  4 | # User-specific files
  5 | *.suo
  6 | *.user
  7 | *.userosscache
  8 | *.sln.docstates
  9 | 
 10 | # User-specific files (MonoDevelop/Xamarin Studio)
 11 | *.userprefs
 12 | 
 13 | # Build results
 14 | [Dd]ebug/
 15 | [Dd]ebugPublic/
 16 | [Rr]elease/
 17 | [Rr]eleases/
 18 | [Xx]64/
 19 | [Xx]86/
 20 | [Bb]uild/
 21 | bld/
 22 | [Bb]in/
 23 | [Oo]bj/
 24 | Help/
 25 | 
 26 | # Visual Studio 2015 cache/options directory
 27 | .vs/
 28 | # Uncomment if you have tasks that create the project's static files in wwwroot
 29 | #wwwroot/
 30 | 
 31 | #Android Noise
 32 | Resource.Designer.cs
 33 | 
 34 | # MSTest test Results
 35 | [Tt]est[Rr]esult*/
 36 | [Bb]uild[Ll]og.*
 37 | 
 38 | # NUNIT
 39 | *.VisualState.xml
 40 | TestResult.xml
 41 | 
 42 | # Build Results of an ATL Project
 43 | [Dd]ebugPS/
 44 | [Rr]eleasePS/
 45 | dlldata.c
 46 | 
 47 | # DNX
 48 | project.lock.json
 49 | artifacts/
 50 | 
 51 | *_i.c
 52 | *_p.c
 53 | *_i.h
 54 | *.ilk
 55 | *.meta
 56 | *.obj
 57 | *.pch
 58 | *.pdb
 59 | *.pgc
 60 | *.pgd
 61 | *.rsp
 62 | *.sbr
 63 | *.tlb
 64 | *.tli
 65 | *.tlh
 66 | *.tmp
 67 | *.tmp_proj
 68 | *.log
 69 | *.vspscc
 70 | *.vssscc
 71 | .builds
 72 | *.pidb
 73 | *.svclog
 74 | *.scc
 75 | 
 76 | # Chutzpah Test files
 77 | _Chutzpah*
 78 | 
 79 | # Visual C++ cache files
 80 | ipch/
 81 | *.aps
 82 | *.ncb
 83 | *.opendb
 84 | *.opensdf
 85 | *.sdf
 86 | *.cachefile
 87 | *.VC.db
 88 | 
 89 | # Visual Studio profiler
 90 | *.psess
 91 | *.vsp
 92 | *.vspx
 93 | *.sap
 94 | 
 95 | # TFS 2012 Local Workspace
 96 | $tf/
 97 | 
 98 | # Guidance Automation Toolkit
 99 | *.gpState
100 | 
101 | # ReSharper is a .NET coding add-in
102 | _ReSharper*/
103 | *.[Rr]e[Ss]harper
104 | *.DotSettings.user
105 | 
106 | # JustCode is a .NET coding add-in
107 | .JustCode
108 | 
109 | # TeamCity is a build add-in
110 | _TeamCity*
111 | 
112 | # DotCover is a Code Coverage Tool
113 | *.dotCover
114 | 
115 | # NCrunch
116 | _NCrunch_*
117 | .*crunch*.local.xml
118 | nCrunchTemp_*
119 | 
120 | # MightyMoose
121 | *.mm.*
122 | AutoTest.Net/
123 | 
124 | # Web workbench (sass)
125 | .sass-cache/
126 | 
127 | # Installshield output folder
128 | [Ee]xpress/
129 | 
130 | # DocProject is a documentation generator add-in
131 | DocProject/buildhelp/
132 | DocProject/Help/*.HxT
133 | DocProject/Help/*.HxC
134 | DocProject/Help/*.hhc
135 | DocProject/Help/*.hhk
136 | DocProject/Help/*.hhp
137 | DocProject/Help/Html2
138 | DocProject/Help/html
139 | 
140 | # Click-Once directory
141 | publish/
142 | 
143 | # Publish Web Output
144 | *.[Pp]ublish.xml
145 | *.azurePubxml
146 | 
147 | # TODO: Un-comment the next line if you do not want to checkin 
148 | # your web deploy settings because they may include unencrypted
149 | # passwords
150 | #*.pubxml
151 | *.publishproj
152 | 
153 | # NuGet Packages
154 | *.nupkg
155 | # The packages folder can be ignored because of Package Restore
156 | **/packages/*
157 | # except build/, which is used as an MSBuild target.
158 | !**/packages/build/
159 | # Uncomment if necessary however generally it will be regenerated when needed
160 | #!**/packages/repositories.config
161 | # NuGet v3's project.json files produces more ignoreable files
162 | *.nuget.props
163 | *.nuget.targets
164 | 
165 | # Microsoft Azure Build Output
166 | csx/
167 | *.build.csdef
168 | 
169 | # Microsoft Azure Emulator
170 | ecf/
171 | rcf/
172 | 
173 | # Microsoft Azure ApplicationInsights config file
174 | ApplicationInsights.config
175 | 
176 | # Windows Store app package directory
177 | AppPackages/
178 | BundleArtifacts/
179 | 
180 | # Visual Studio cache files
181 | # files ending in .cache can be ignored
182 | *.[Cc]ache
183 | # but keep track of directories ending in .cache
184 | !*.[Cc]ache/
185 | 
186 | # Others
187 | ClientBin/
188 | [Ss]tyle[Cc]op.*
189 | ~$*
190 | *~
191 | *.dbmdl
192 | *.dbproj.schemaview
193 | *.pfx
194 | *.publishsettings
195 | node_modules/
196 | orleans.codegen.cs
197 | 
198 | # RIA/Silverlight projects
199 | Generated_Code/
200 | 
201 | # Backup & report files from converting an old project file
202 | # to a newer Visual Studio version. Backup files are not needed,
203 | # because we have git ;-)
204 | _UpgradeReport_Files/
205 | Backup*/
206 | UpgradeLog*.XML
207 | UpgradeLog*.htm
208 | 
209 | # SQL Server files
210 | *.mdf
211 | *.ldf
212 | 
213 | # Business Intelligence projects
214 | *.rdl.data
215 | *.bim.layout
216 | *.bim_*.settings
217 | 
218 | # Microsoft Fakes
219 | FakesAssemblies/
220 | 
221 | # GhostDoc plugin setting file
222 | *.GhostDoc.xml
223 | 
224 | # Node.js Tools for Visual Studio
225 | .ntvs_analysis.dat
226 | 
227 | # Visual Studio 6 build log
228 | *.plg
229 | 
230 | # Visual Studio 6 workspace options file
231 | *.opt
232 | 
233 | # Visual Studio LightSwitch build output
234 | **/*.HTMLClient/GeneratedArtifacts
235 | **/*.DesktopClient/GeneratedArtifacts
236 | **/*.DesktopClient/ModelManifest.xml
237 | **/*.Server/GeneratedArtifacts
238 | **/*.Server/ModelManifest.xml
239 | _Pvt_Extensions
240 | 
241 | # LightSwitch generated files
242 | GeneratedArtifacts/
243 | ModelManifest.xml
244 | 
245 | # Paket dependency manager
246 | .paket/paket.exe
247 | 
248 | # FAKE - F# Make
249 | .fake/
250 | *.bak
251 | 


--------------------------------------------------------------------------------
/TestAndroid/packages.config:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <packages>
 3 |   <package id="Microsoft.CSharp" version="4.6.0" targetFramework="monoandroid11.0" />
 4 |   <package id="Microsoft.NETCore.Platforms" version="3.0.0" targetFramework="monoandroid11.0" />
 5 |   <package id="Microsoft.Win32.Primitives" version="4.3.0" targetFramework="monoandroid90" />
 6 |   <package id="NETStandard.Library" version="1.6.1" targetFramework="monoandroid11.0" />
 7 |   <package id="Newtonsoft.Json" version="12.0.3" targetFramework="monoandroid11.0" />
 8 |   <package id="System.AppContext" version="4.3.0" targetFramework="monoandroid90" />
 9 |   <package id="System.Collections" version="4.3.0" targetFramework="monoandroid90" />
10 |   <package id="System.Collections.Concurrent" version="4.3.0" targetFramework="monoandroid90" />
11 |   <package id="System.Console" version="4.3.0" targetFramework="monoandroid11.0" />
12 |   <package id="System.Diagnostics.Debug" version="4.3.0" targetFramework="monoandroid90" />
13 |   <package id="System.Diagnostics.Tools" version="4.3.0" targetFramework="monoandroid90" />
14 |   <package id="System.Diagnostics.Tracing" version="4.3.0" targetFramework="monoandroid90" />
15 |   <package id="System.Globalization" version="4.3.0" targetFramework="monoandroid90" />
16 |   <package id="System.Globalization.Calendars" version="4.3.0" targetFramework="monoandroid90" />
17 |   <package id="System.IO" version="4.3.0" targetFramework="monoandroid90" />
18 |   <package id="System.IO.Compression" version="4.3.0" targetFramework="monoandroid90" />
19 |   <package id="System.IO.Compression.ZipFile" version="4.3.0" targetFramework="monoandroid90" />
20 |   <package id="System.IO.FileSystem" version="4.3.0" targetFramework="monoandroid90" />
21 |   <package id="System.IO.FileSystem.Primitives" version="4.3.0" targetFramework="monoandroid90" />
22 |   <package id="System.Linq" version="4.3.0" targetFramework="monoandroid90" />
23 |   <package id="System.Linq.Expressions" version="4.3.0" targetFramework="monoandroid90" />
24 |   <package id="System.Net.Http" version="4.3.0" targetFramework="monoandroid11.0" />
25 |   <package id="System.Net.Primitives" version="4.3.0" targetFramework="monoandroid11.0" />
26 |   <package id="System.Net.Sockets" version="4.3.0" targetFramework="monoandroid90" />
27 |   <package id="System.ObjectModel" version="4.3.0" targetFramework="monoandroid90" />
28 |   <package id="System.Reflection" version="4.3.0" targetFramework="monoandroid90" />
29 |   <package id="System.Reflection.Extensions" version="4.3.0" targetFramework="monoandroid90" />
30 |   <package id="System.Reflection.Primitives" version="4.3.0" targetFramework="monoandroid90" />
31 |   <package id="System.Resources.ResourceManager" version="4.3.0" targetFramework="monoandroid90" />
32 |   <package id="System.Runtime" version="4.3.0" targetFramework="monoandroid11.0" />
33 |   <package id="System.Runtime.Extensions" version="4.3.0" targetFramework="monoandroid11.0" />
34 |   <package id="System.Runtime.Handles" version="4.3.0" targetFramework="monoandroid90" />
35 |   <package id="System.Runtime.InteropServices" version="4.3.0" targetFramework="monoandroid90" />
36 |   <package id="System.Runtime.InteropServices.RuntimeInformation" version="4.3.0" targetFramework="monoandroid90" />
37 |   <package id="System.Runtime.Numerics" version="4.3.0" targetFramework="monoandroid90" />
38 |   <package id="System.Security.Cryptography.Algorithms" version="4.3.0" targetFramework="monoandroid11.0" />
39 |   <package id="System.Security.Cryptography.Encoding" version="4.3.0" targetFramework="monoandroid90" />
40 |   <package id="System.Security.Cryptography.Primitives" version="4.3.0" targetFramework="monoandroid90" />
41 |   <package id="System.Security.Cryptography.X509Certificates" version="4.3.0" targetFramework="monoandroid11.0" />
42 |   <package id="System.Text.Encoding" version="4.3.0" targetFramework="monoandroid90" />
43 |   <package id="System.Text.Encoding.Extensions" version="4.3.0" targetFramework="monoandroid90" />
44 |   <package id="System.Text.RegularExpressions" version="4.3.0" targetFramework="monoandroid11.0" />
45 |   <package id="System.Threading" version="4.3.0" targetFramework="monoandroid90" />
46 |   <package id="System.Threading.Tasks" version="4.3.0" targetFramework="monoandroid90" />
47 |   <package id="System.Threading.Timer" version="4.3.0" targetFramework="monoandroid90" />
48 |   <package id="System.Xml.ReaderWriter" version="4.3.0" targetFramework="monoandroid11.0" />
49 |   <package id="System.Xml.XDocument" version="4.3.0" targetFramework="monoandroid90" />
50 |   <package id="xunit" version="2.4.1" targetFramework="monoandroid90" />
51 |   <package id="xunit.abstractions" version="2.0.3" targetFramework="monoandroid90" />
52 |   <package id="xunit.analyzers" version="0.10.0" targetFramework="monoandroid90" />
53 |   <package id="xunit.assert" version="2.4.1" targetFramework="monoandroid90" />
54 |   <package id="xunit.core" version="2.4.1" targetFramework="monoandroid90" />
55 |   <package id="xunit.extensibility.core" version="2.4.1" targetFramework="monoandroid90" />
56 |   <package id="xunit.extensibility.execution" version="2.4.1" targetFramework="monoandroid90" />
57 |   <package id="xunit.runner.visualstudio" version="2.1.0" targetFramework="monoandroid11.0" />
58 | </packages>


--------------------------------------------------------------------------------
/TestApp/TestForm.Designer.cs:
--------------------------------------------------------------------------------
  1 | namespace TestApp
  2 | {
  3 |     partial class TestForm
  4 |     {
  5 |         /// <summary>
  6 |         /// Required designer variable.
  7 |         /// </summary>
  8 |         private System.ComponentModel.IContainer components = null;
  9 | 
 10 |         /// <summary>
 11 |         /// Clean up any resources being used.
 12 |         /// </summary>
 13 |         /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
 14 |         protected override void Dispose(bool disposing)
 15 |         {
 16 |             if (disposing && (components != null))
 17 |             {
 18 |                 components.Dispose();
 19 |             }
 20 |             base.Dispose(disposing);
 21 |         }
 22 | 
 23 |         #region Windows Form Designer generated code
 24 | 
 25 |         /// <summary>
 26 |         /// Required method for Designer support - do not modify
 27 |         /// the contents of this method with the code editor.
 28 |         /// </summary>
 29 |         private void InitializeComponent()
 30 |         {
 31 |             System.Windows.Forms.TreeNode treeNode1 = new System.Windows.Forms.TreeNode("Node4");
 32 |             System.Windows.Forms.TreeNode treeNode2 = new System.Windows.Forms.TreeNode("Node8");
 33 |             System.Windows.Forms.TreeNode treeNode3 = new System.Windows.Forms.TreeNode("Node9");
 34 |             System.Windows.Forms.TreeNode treeNode4 = new System.Windows.Forms.TreeNode("Node5", new System.Windows.Forms.TreeNode[] {
 35 |             treeNode2,
 36 |             treeNode3});
 37 |             System.Windows.Forms.TreeNode treeNode5 = new System.Windows.Forms.TreeNode("Node1", new System.Windows.Forms.TreeNode[] {
 38 |             treeNode1,
 39 |             treeNode4});
 40 |             System.Windows.Forms.TreeNode treeNode6 = new System.Windows.Forms.TreeNode("Node2");
 41 |             System.Windows.Forms.TreeNode treeNode7 = new System.Windows.Forms.TreeNode("Node6");
 42 |             System.Windows.Forms.TreeNode treeNode8 = new System.Windows.Forms.TreeNode("Node7");
 43 |             System.Windows.Forms.TreeNode treeNode9 = new System.Windows.Forms.TreeNode("Node3", new System.Windows.Forms.TreeNode[] {
 44 |             treeNode7,
 45 |             treeNode8});
 46 |             System.Windows.Forms.TreeNode treeNode10 = new System.Windows.Forms.TreeNode("Node0", new System.Windows.Forms.TreeNode[] {
 47 |             treeNode5,
 48 |             treeNode6,
 49 |             treeNode9});
 50 |             System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(TestForm));
 51 |             this.treeView1 = new System.Windows.Forms.TreeView();
 52 |             this.richTextBox1 = new System.Windows.Forms.RichTextBox();
 53 |             this.SuspendLayout();
 54 |             // 
 55 |             // treeView1
 56 |             // 
 57 |             this.treeView1.Dock = System.Windows.Forms.DockStyle.Left;
 58 |             this.treeView1.Location = new System.Drawing.Point(0, 0);
 59 |             this.treeView1.Name = "treeView1";
 60 |             treeNode1.Name = "Node4";
 61 |             treeNode1.Text = "Node4";
 62 |             treeNode2.Name = "Node8";
 63 |             treeNode2.Text = "Node8";
 64 |             treeNode3.Name = "Node9";
 65 |             treeNode3.Text = "Node9";
 66 |             treeNode4.Name = "Node5";
 67 |             treeNode4.Text = "Node5";
 68 |             treeNode5.Name = "Node1";
 69 |             treeNode5.Text = "Node1";
 70 |             treeNode6.Name = "Node2";
 71 |             treeNode6.Text = "Node2";
 72 |             treeNode7.Name = "Node6";
 73 |             treeNode7.Text = "Node6";
 74 |             treeNode8.Name = "Node7";
 75 |             treeNode8.Text = "Node7";
 76 |             treeNode9.Name = "Node3";
 77 |             treeNode9.Text = "Node3";
 78 |             treeNode10.Name = "Node0";
 79 |             treeNode10.Text = "Node0";
 80 |             this.treeView1.Nodes.AddRange(new System.Windows.Forms.TreeNode[] {
 81 |             treeNode10});
 82 |             this.treeView1.Size = new System.Drawing.Size(231, 336);
 83 |             this.treeView1.TabIndex = 0;
 84 |             // 
 85 |             // richTextBox1
 86 |             // 
 87 |             this.richTextBox1.Dock = System.Windows.Forms.DockStyle.Fill;
 88 |             this.richTextBox1.Location = new System.Drawing.Point(231, 0);
 89 |             this.richTextBox1.Name = "richTextBox1";
 90 |             this.richTextBox1.Size = new System.Drawing.Size(384, 336);
 91 |             this.richTextBox1.TabIndex = 1;
 92 |             this.richTextBox1.Text = resources.GetString("richTextBox1.Text");
 93 |             // 
 94 |             // TestForm
 95 |             // 
 96 |             this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
 97 |             this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
 98 |             this.ClientSize = new System.Drawing.Size(615, 336);
 99 |             this.Controls.Add(this.richTextBox1);
100 |             this.Controls.Add(this.treeView1);
101 |             this.Name = "TestForm";
102 |             this.Text = "TestForm";
103 |             this.ResumeLayout(false);
104 | 
105 |         }
106 | 
107 |         #endregion
108 | 
109 |         private System.Windows.Forms.TreeView treeView1;
110 |         private System.Windows.Forms.RichTextBox richTextBox1;
111 |     }
112 | }


--------------------------------------------------------------------------------
/TestAndroid/TestAdapter.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Collections.Generic;
  3 | using System.Linq;
  4 | using System.Text;
  5 | 
  6 | using Android.App;
  7 | using Android.Content;
  8 | using Android.OS;
  9 | using Android.Runtime;
 10 | using Android.Views;
 11 | using Android.Widget;
 12 | using System.Reflection;
 13 | using System.Threading.Tasks;
 14 | using Xunit;
 15 | using Galador.Reflection.Utils;
 16 | 
 17 | namespace TestAndroid
 18 | {
 19 |     class TestRow
 20 |     {
 21 |         public bool IsHeader;
 22 |         public Type TestType;
 23 |         public MethodInfo TestMethod;
 24 |         public bool Success;
 25 |     }
 26 |     public class TestAdapter : BaseAdapter
 27 |     {
 28 |         Activity activity;
 29 |         List<TestRow> testInfo;
 30 |         List<TestRow> list = new List<TestRow>();
 31 | 
 32 |         public TestAdapter(Activity activity, params Type[] testTypes)
 33 |         {
 34 |             this.activity = activity;
 35 |             testInfo = new List<TestRow>();
 36 |             foreach (var t in testTypes)
 37 |             {
 38 |                 testInfo.Add(new TestRow
 39 |                 {
 40 |                     IsHeader = true,
 41 |                     TestType = t,
 42 |                 });
 43 |                 var methods = from m in t.GetMethods()
 44 |                               let fa = Attribute.GetCustomAttribute(m, typeof(FactAttribute))
 45 |                               where fa != null
 46 |                               select m;
 47 |                 foreach (var item in methods)
 48 |                     testInfo.Add(new TestRow
 49 |                     {
 50 |                         TestMethod = item,
 51 |                     });
 52 |             }
 53 |         }
 54 | 
 55 |         public Task Run()
 56 |         {
 57 |             if (IsRunning)
 58 |                 return Task.FromResult(false);
 59 |             IsRunning = true;
 60 |             list.Clear();
 61 |             base.NotifyDataSetChanged();
 62 |             var t = new TaskCompletionSource<bool>();
 63 |             new Java.Lang.Thread(() =>
 64 |             {
 65 |                 try { RunImpl(); }
 66 |                 finally
 67 |                 {
 68 |                     IsRunning = false;
 69 |                     t.TrySetResult(true);
 70 |                 }
 71 |             }).Start();
 72 |             return t.Task;
 73 |         }
 74 |         public bool IsRunning { get; private set; }
 75 | 
 76 |         void RunImpl()
 77 |         {
 78 |             object target = null;
 79 |             foreach (var item in testInfo)
 80 |             {
 81 |                 if (item.IsHeader)
 82 |                 {
 83 |                     if (item is IDisposable)
 84 |                         ((IDisposable)item).Dispose();
 85 |                     target = Activator.CreateInstance(item.TestType);
 86 |                 }
 87 |                 else if (!item.IsHeader)
 88 |                 {
 89 |                     try
 90 |                     {
 91 |                         item.TestMethod.Invoke(target, Array.Empty<object>());
 92 |                         item.Success = true;
 93 |                     }
 94 |                     catch
 95 |                     {
 96 |                         item.Success = false;
 97 |                     }
 98 |                 }
 99 |                 activity.RunOnUiThread(() => 
100 |                 {
101 |                     list.Add(item);
102 |                     base.NotifyDataSetChanged();
103 |                 });
104 |             }
105 |         }
106 | 
107 |         public class JavaJobObject : Java.Lang.Object
108 |         {
109 |             internal TestRow Item;
110 |         }
111 | 
112 |         public override int Count { get { lock (list) return list != null ? list.Count : 0; } }
113 | 
114 |         public override Java.Lang.Object GetItem(int position)
115 |         {
116 |             lock (list)
117 |             {
118 |                 if (list == null || position < 0 || position >= list.Count)
119 |                     return null;
120 |                 return new JavaJobObject { Item = list[position] };
121 |             }
122 |         }
123 | 
124 |         public override long GetItemId(int position)
125 |         {
126 |             return position;
127 |         }
128 | 
129 |         public override Android.Views.View GetView(int position, Android.Views.View convertView, ViewGroup parent)
130 |         {
131 |             TestRow row;
132 |             lock (list) { row = list[position]; }
133 | 
134 |             if (row.IsHeader)
135 |             {
136 |                 var view = (convertView as TextView);
137 |                 if (view == null)
138 |                 {
139 |                     view = new TextView(parent.Context);
140 |                     view.SetPadding(5, 5, 5, 5);
141 |                     view.TextSize = 22;
142 |                 }
143 |                 var name = row.TestType.Name;
144 |                 var sb = new StringBuilder(name.Length + 2);
145 |                 for (int i = 0; i < name.Length; i++)
146 |                 {
147 |                     if (i > 0 && char.IsUpper(name[i]))
148 |                         sb.Append(' ');
149 |                     sb.Append(char.ToUpper(name[i]));
150 |                 }
151 |                 view.Text = sb.ToString();
152 |                 return view;
153 |             }
154 |             else
155 |             {
156 |                 var view = (convertView as RelativeLayout);
157 |                 if (view == null)
158 |                 {
159 |                     var inflated = LayoutInflater.From(activity).Inflate(Resource.Layout.LayoutTest, parent, false);
160 |                     view = (RelativeLayout)inflated;
161 |                 }
162 |                 var mm = view.FindViewById<TextView>(Resource.Id.resultMethod);
163 |                 mm.Text = row.TestMethod.Name;
164 |                 var cr = view.FindViewById<CheckBox>(Resource.Id.resultCheckBox);
165 |                 cr.Checked = row.Success;
166 |                 return view;
167 |             }
168 |         }
169 |     }
170 | }


--------------------------------------------------------------------------------
/Galador.Reflection/Serialization/IO/TokenPrimitiveWriter.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Collections.Generic;
  3 | using System.Linq;
  4 | using System.Threading.Tasks;
  5 | 
  6 | namespace Galador.Reflection.Serialization.IO
  7 | {
  8 |     /// <summary>
  9 |     /// An <see cref="IPrimitiveWriter"/> that write data to an object list. It is faster for cloning and also make it easier to debug serialization.
 10 |     /// </summary>
 11 |     public class TokenPrimitiveWriter : IPrimitiveWriter
 12 |     {
 13 |         List<object> stream;
 14 | 
 15 |         /// <summary>
 16 |         /// Create a new <see cref="TokenPrimitiveWriter"/> from a list.
 17 |         /// </summary>
 18 |         /// <param name="stream">The target list, where data will be written.</param>
 19 |         public TokenPrimitiveWriter(List<object> stream)
 20 |         {
 21 |             if (stream == null)
 22 |                 throw new ArgumentNullException();
 23 |             this.stream = stream;
 24 |         }
 25 |         /// <summary>
 26 |         /// Create a new <see cref="TokenPrimitiveWriter"/> and its underlying list.
 27 |         /// </summary>
 28 |         public TokenPrimitiveWriter() { this.stream = new List<object>(256); }
 29 | 
 30 |         /// <summary>
 31 |         /// The list where token will be written.
 32 |         /// </summary>
 33 |         public List<object> TokenStream { get { return stream; } }
 34 | 
 35 |         void IDisposable.Dispose() { }
 36 |         void IPrimitiveWriter.Write(char value) { stream.Add(value); }
 37 |         void IPrimitiveWriter.Write(sbyte value) { stream.Add(value); }
 38 |         void IPrimitiveWriter.Write(ushort value) { stream.Add(value); }
 39 |         void IPrimitiveWriter.Write(uint value) { stream.Add(value); }
 40 |         void IPrimitiveWriter.Write(ulong value) { stream.Add(value); }
 41 |         void IPrimitiveWriter.Write(double value) { stream.Add(value); }
 42 |         void IPrimitiveWriter.Write(decimal value) { stream.Add(value); }
 43 |         void IPrimitiveWriter.Write(float value) { stream.Add(value); }
 44 |         void IPrimitiveWriter.Write(long value) { stream.Add(value); }
 45 |         void IPrimitiveWriter.Write(int value) { stream.Add(value); }
 46 |         void IPrimitiveWriter.Write(short value) { stream.Add(value); }
 47 |         void IPrimitiveWriter.Write(byte value) { stream.Add(value); }
 48 |         void IPrimitiveWriter.Write(bool value) { stream.Add(value); }
 49 |         void IPrimitiveWriter.Write(Guid value) { stream.Add(value); }
 50 |         void IPrimitiveWriter.Write(byte[] value) { stream.Add(value); }
 51 |         void IPrimitiveWriter.Write(string value) { stream.Add(value); }
 52 |         void IPrimitiveWriter.WriteVInt(ulong? value) { stream.Add(value); }
 53 |         void IPrimitiveWriter.WriteVInt(long? value) { stream.Add(value); }
 54 |         void IPrimitiveWriter.WriteVInt(ulong value) { stream.Add(value); }
 55 |         void IPrimitiveWriter.WriteVInt(long value) { stream.Add(value); }
 56 |     }
 57 | 
 58 |     /// <summary>
 59 |     /// An <see cref="IPrimitiveReader"/> that read the data from an object list. It is faster for cloning and also make it easier to debug serialization.
 60 |     /// </summary>
 61 |     public class TokenPrimitiveReader : IPrimitiveReader
 62 |     {
 63 |         List<object> stream;
 64 | 
 65 |         /// <summary>
 66 |         /// Construct a new <see cref="TokenPrimitiveReader"/>
 67 |         /// </summary>
 68 |         /// <param name="stream">The source of token</param>
 69 |         public TokenPrimitiveReader(List<object> stream)
 70 |         {
 71 |             if (stream == null)
 72 |                 throw new ArgumentNullException();
 73 |             this.stream = stream;
 74 |         }
 75 |         /// <summary>
 76 |         /// Current position in the list of token.
 77 |         /// </summary>
 78 |         public int Position
 79 |         {
 80 |             get { return position; }
 81 |             set
 82 |             {
 83 |                 if (value < 0 || value >= stream.Count)
 84 |                     throw new ArgumentOutOfRangeException();
 85 |                 position = value;
 86 |             }
 87 |         }
 88 |         int position;
 89 | 
 90 |         /// <summary>
 91 |         /// The source of values.
 92 |         /// </summary>
 93 |         public List<object> TokenStream { get { return stream; } }
 94 | 
 95 |         string IPrimitiveReader.ReadString() { return (string)stream[position++]; }
 96 |         byte[] IPrimitiveReader.ReadBytes() { return (byte[])stream[position++]; }
 97 |         Guid IPrimitiveReader.ReadGuid() { return (Guid)stream[position++]; }
 98 |         bool IPrimitiveReader.ReadBool() { return (bool)stream[position++]; }
 99 |         char IPrimitiveReader.ReadChar() { return (char)stream[position++]; }
100 |         byte IPrimitiveReader.ReadByte() { return (byte)stream[position++]; }
101 |         sbyte IPrimitiveReader.ReadSByte() { return (sbyte)stream[position++]; }
102 |         short IPrimitiveReader.ReadInt16() { return (short)stream[position++]; }
103 |         ushort IPrimitiveReader.ReadUInt16() { return (ushort)stream[position++]; }
104 |         int IPrimitiveReader.ReadInt32() { return (int)stream[position++]; }
105 |         uint IPrimitiveReader.ReadUInt32() { return (uint)stream[position++]; }
106 |         long IPrimitiveReader.ReadInt64() { return (long)stream[position++]; }
107 |         ulong IPrimitiveReader.ReadUInt64() { return (ulong)stream[position++]; }
108 |         float IPrimitiveReader.ReadSingle() { return (float)stream[position++]; }
109 |         double IPrimitiveReader.ReadDouble() { return (double)stream[position++]; }
110 |         decimal IPrimitiveReader.ReadDecimal() { return (decimal)stream[position++]; }
111 |         long IPrimitiveReader.ReadVInt() { return (long)stream[position++]; }
112 |         ulong IPrimitiveReader.ReadVUInt() { return (ulong)stream[position++]; }
113 |         long? IPrimitiveReader.ReadVNInt() { return (long?)stream[position++]; }
114 |         ulong? IPrimitiveReader.ReadVNUInt() { return (ulong?)stream[position++]; }
115 |         void IDisposable.Dispose() { }
116 |     }
117 | }
118 | 


--------------------------------------------------------------------------------
/Galador.Reflection/Serialization/Serializer.cs:
--------------------------------------------------------------------------------
  1 | using Galador.Reflection.Serialization.IO;
  2 | using System;
  3 | using System.Collections.Generic;
  4 | using System.Globalization;
  5 | using System.IO;
  6 | using System.IO.Compression;
  7 | using System.Text;
  8 | 
  9 | namespace Galador.Reflection.Serialization
 10 | {
 11 |     /// <summary>
 12 |     /// Handy helper class to perform typical serialization operation in just one method call.
 13 |     /// </summary>
 14 |     public static class Serializer
 15 |     {
 16 |         /// <summary>
 17 |         /// Serializes the specified object <paramref name="o"/> as a string.
 18 |         /// </summary>
 19 |         /// <param name="o">The object to serialize.</param>
 20 |         /// <param name="target">The target where the serialized version will be written.</param>
 21 |         /// <param name="settings">The serialization settings to use</param>
 22 |         public static void Serialize(object o, IPrimitiveWriter target, SerializationSettings settings = null)
 23 |         {
 24 |             var ow = new Writer(target) { Settings = settings };
 25 |             ow.Write(o);
 26 |         }
 27 | 
 28 |         /// <summary>
 29 |         /// Deserialize an object from a string.
 30 |         /// </summary>
 31 |         /// <param name="source">The string to read as a serialized object.</param>
 32 |         /// <returns>A newly deserialized object.</returns>
 33 |         public static object Deserialize(IPrimitiveReader source)
 34 |         {
 35 |             var or = new Reader(source);
 36 |             return or.Read();
 37 |         }
 38 | 
 39 |         public static T Deserialize<T>(IPrimitiveReader source, T suggested = default(T))
 40 |         {
 41 |             var or = new Reader(source);
 42 |             return or.Read<T>(suggested);
 43 |         }
 44 | 
 45 |         /// <summary>
 46 |         /// Serializes the specified object <paramref name="o"/> to a compressed gzip stream.
 47 |         /// </summary>
 48 |         /// <param name="o">The object to serialize.</param>
 49 |         /// <param name="target">The target where the serialized version will be written.</param>
 50 |         /// <param name="settings">The serialization settings to use</param>
 51 |         public static void ZipSerialize(object o, Stream stream, SerializationSettings settings = null)
 52 |         {
 53 |             using (var gzStream = new GZipStream(stream, CompressionMode.Compress, true))
 54 |                 Serialize(o, new PrimitiveBinaryWriter(gzStream), settings);
 55 |         }
 56 |         /// <summary>
 57 |         /// Deserialize an object from a compressed gzip stream.
 58 |         /// </summary>
 59 |         /// <param name="source">The stream to read as a serialized object.</param>
 60 |         /// <returns>A newly deserialized object.</returns>
 61 |         public static object ZipDeserialize(Stream stream)
 62 |         {
 63 |             using (var gzStream = new GZipStream(stream, CompressionMode.Decompress, true))
 64 |                 return Deserialize(new PrimitiveBinaryReader(gzStream));
 65 |         }
 66 | 
 67 |         public static T ZipDeserialize<T>(Stream stream, T suggested = default(T))
 68 |         {
 69 |             using (var gzStream = new GZipStream(stream, CompressionMode.Decompress, true))
 70 |                 return Deserialize<T>(new PrimitiveBinaryReader(gzStream), suggested);
 71 |         }
 72 | 
 73 |         /// <summary>
 74 |         /// Perform a deep clone operation by serializing then deserializing an object.
 75 |         /// </summary>
 76 |         /// <typeparam name="T">The type of the object to clone.</typeparam>
 77 |         /// <param name="instance">The instance to clone.</param>
 78 |         /// <param name="settings">The settings to use with the <see cref="ObjectWriter"/></param>
 79 |         /// <returns>A deep clone of the <paramref name="instance"/>.</returns>
 80 |         public static T Clone<T>(T instance, SerializationSettings settings = null)
 81 |         {
 82 |             var ms = new List<object>(256);
 83 | 
 84 |             var pw = new TokenPrimitiveWriter(ms);
 85 |             var ow = new Writer(pw)
 86 |             {
 87 |                 Settings = new SerializationSettings
 88 |                 {
 89 |                     IgnoreISerializable = settings?.IgnoreISerializable ?? true,
 90 |                     IgnoreTypeConverter = settings?.IgnoreTypeConverter ?? true,
 91 |                 },
 92 |             };
 93 | 
 94 |             ow.Write(instance);
 95 | 
 96 |             var pr = new TokenPrimitiveReader(ms);
 97 |             var or = new Reader(pr);
 98 | 
 99 |             var result = or.Read();
100 |             return (T)result;
101 |         }
102 | 
103 |         public static T Transmogrify<T>(object instance, SerializationSettings settings = null) => (T)Transmogrify(instance, typeof(T), settings);
104 | 
105 |         public static object Transmogrify(object instance, Type toType, SerializationSettings settings = null)
106 |         {
107 |             var ms = new List<object>(256);
108 | 
109 |             var pw = new TokenPrimitiveWriter(ms);
110 |             var ow = new Writer(pw)
111 |             {
112 |                 Settings = new SerializationSettings
113 |                 {
114 |                     IgnoreISerializable = settings?.IgnoreISerializable ?? true,
115 |                     IgnoreTypeConverter = settings?.IgnoreTypeConverter ?? true,
116 |                 },
117 |             };
118 | 
119 |             ow.Write(instance);
120 | 
121 |             var pr = new TokenPrimitiveReader(ms);
122 |             var or = new Reader(pr);
123 | 
124 |             var result = or.Read(toType);
125 |             return result;
126 |         }
127 | 
128 |         /// <summary>
129 |         /// Serialize the <paramref name="instance"/> as a string and returns it.
130 |         /// </summary>
131 |         /// <param name="instance">The instance to serialize as a string.</param>
132 |         /// <param name="settings">The serialization settings to use</param>
133 |         /// <returns>A string version of the object.</returns>
134 |         public static string ToSerializedString(object instance, SerializationSettings settings = null)
135 |         {
136 |             var sb = new StringBuilder(256);
137 |             Serialize(instance, new PrimitiveTextWriter(new StringWriter(sb, CultureInfo.InvariantCulture)), settings);
138 |             return sb.ToString();
139 |         }
140 |     }
141 | }
142 | 


--------------------------------------------------------------------------------
/TestApp/DocumentTest.cs:
--------------------------------------------------------------------------------
  1 | using Galador.Reflection.Serialization;
  2 | using System;
  3 | using System.Collections;
  4 | using System.Collections.Generic;
  5 | using System.Diagnostics;
  6 | using System.Linq;
  7 | using System.Text;
  8 | using System.Threading.Tasks;
  9 | 
 10 | namespace TestApp;
 11 | 
 12 | public class DocumentTest
 13 | {
 14 |     // had an error in my code that caused the serialization to fail
 15 |     // simple repro below (should not fail, of course!)
 16 |     [Fact]
 17 |     public void TestMapDocSerialization()
 18 |     {
 19 |         var memt = new MemTraceListener();
 20 |         Trace.Listeners.Add(memt);
 21 | 
 22 |         var map = new TestMap();
 23 |         map.Layers.Add(new TestVectorLayer() { Name = "Layer 1" });
 24 |         map.Layers.Add(new TestVectorLayer() { Name = "Layer 2" });
 25 | 
 26 |         var map2 = map.Clone() as TestMap;
 27 |         Assert.Equal(map.Layers.Count, map2!.Layers.Count);
 28 | 
 29 |         var deserialized = Serializer.Clone(map2);
 30 |         // this fails, but the unexpected datat structure caused unexpeceted deserialization
 31 |         // make sure there is an Asset warning
 32 |         Assert.Contains(memt.Messages, x => x.Contains("Object.Read()"));
 33 |     }
 34 | 
 35 |     class MemTraceListener : TraceListener
 36 |     {
 37 |         public List<string> Messages { get; } = new List<string>();
 38 |         StringBuilder currentLine = new StringBuilder(); 
 39 | 
 40 |         public override void Write(string? message)
 41 |         {
 42 |             currentLine.Append(message);
 43 |         }
 44 |         public override void WriteLine(string? message)
 45 |         {
 46 |             if (currentLine.Length > 0)
 47 |             {
 48 |                 currentLine.Append(message);
 49 |                 Messages.Add(currentLine.ToString());
 50 |                 currentLine.Clear();
 51 |             }
 52 |             else if (!string.IsNullOrEmpty(message))
 53 |             {
 54 |                 Messages.Add(message);
 55 |             }
 56 |         }
 57 |     }
 58 | 
 59 |     public interface IParented
 60 |     {
 61 |         object? Parent { get; set; }
 62 |     }
 63 |     [SerializationSettings(false, IncludeFields = true)]
 64 |     public class TestList<T> : ICollection<T>, IParented, ICloneable
 65 |     {
 66 |         List<T> _innerList = new List<T>();
 67 | 
 68 |         public TestList(object? parent)
 69 |         {
 70 |             Parent = parent;
 71 |         }
 72 |         public object? Parent { get; set; }
 73 | 
 74 |         public int Count => _innerList.Count;
 75 |         public bool IsReadOnly => false;
 76 |         public void Add(T item)
 77 |         {
 78 |             if (item is IParented p)
 79 |                 p.Parent = this;
 80 |             _innerList.Add(item);
 81 |         }
 82 |         public void AddRange(params IEnumerable<T> item)
 83 |         {
 84 |             foreach (var i in item)
 85 |             {
 86 |                 if (i is IParented p)
 87 |                     p.Parent = this;
 88 |             }
 89 |             _innerList.AddRange(item);
 90 |         }
 91 |         public void Clear() => _innerList.Clear();
 92 |         public bool Contains(T item) => _innerList.Contains(item);
 93 |         public void CopyTo(T[] array, int arrayIndex) => _innerList.CopyTo(array, arrayIndex);
 94 |         public IEnumerator<T> GetEnumerator() => _innerList.GetEnumerator();
 95 |         public bool Remove(T item) => _innerList.Remove(item);
 96 |         IEnumerator IEnumerable.GetEnumerator() => _innerList.GetEnumerator();
 97 | 
 98 |         public object Clone()
 99 |         {
100 |             var l = (TestList<T>)MemberwiseClone();
101 |             l._innerList = _innerList.Select(x =>
102 |             {
103 |                 if (x is ICloneable c && x is IParented)
104 |                 {
105 |                     var x2 = (T)c.Clone();
106 |                     ((IParented)x2).Parent = l;
107 |                     return x2;
108 |                 }
109 |                 else
110 |                 {
111 |                     return x;
112 |                 }
113 |             }).ToList();
114 |             return l;
115 |         }
116 |     }
117 | 
118 |     [SerializationSettings(false, IncludeFields = true)]
119 |     public class TestMap : ICloneable
120 |     {
121 |         public TestMap()
122 |         {
123 |             mLayers = new TestList<TestVectorLayer>(this);
124 |         }
125 | 
126 |         public TestList<TestVectorLayer> Layers => mLayers;
127 |         TestList<TestVectorLayer> mLayers;
128 | 
129 |         public object Clone()
130 |         {
131 |             var m = (TestMap)MemberwiseClone();
132 |             m.mLayers = (TestList<TestVectorLayer>)mLayers.Clone();
133 |             m.mLayers.Parent = m;
134 |             return m;
135 |         }
136 |     }
137 |     [SerializationSettings(false, IncludeFields = true)]
138 |     public class TestVectorLayer : ICloneable, IParented
139 |     {
140 |         public TestVectorLayer()
141 |         {
142 |             mItems = new TestList<TestLayerItem>(this);
143 |         }
144 |         public object? Parent { get; set; }
145 | 
146 |         [NotSerialized]
147 |         public TestList<TestLayerItem> Items => mItems;
148 |         [Serialized]
149 |         TestList<TestLayerItem> mItems;
150 | 
151 |         public string? Name { get; set; }
152 | 
153 |         public object Clone()
154 |         {
155 |             var l = (TestVectorLayer)MemberwiseClone();
156 |             l.mItems = new TestList<TestLayerItem>(this); // this was a bug in my code, that cause very strange deserialization!
157 |             //l.mItems = new DocumentList<TestLayerItem>(l);
158 |             l.mItems.AddRange(mItems.Select(x => (TestLayerItem)x.Clone()));
159 |             return l;
160 |         }
161 |     }
162 |     public class TestLayerItem : ICloneable, IParented
163 |     {
164 |         public TestLayerItem()
165 |         {
166 |         }
167 |         public TestLayerItem(string name)
168 |         {
169 |             Name = name;
170 |         }
171 |         public object? Parent 
172 |         {
173 |             get => field;
174 |             set => value = field;
175 |         }
176 | 
177 | 
178 |         public string? Name { get; set; }
179 |         public object Clone()
180 |         {
181 |             var l = (TestVectorLayer)MemberwiseClone();
182 |             l.Parent = null;
183 |             return l;
184 |         }
185 |     }
186 | }
187 | 


--------------------------------------------------------------------------------
/registry.md:
--------------------------------------------------------------------------------
  1 | 
  2 | ## Introduction
  3 | 
  4 | In my application I needed to be able to dynamically load type and their dependency at runtime. 
  5 | My few interaction with various IoC framework / library were not the most successful. Except with MEF, which seemed great at the time!
  6 | Except every time I wanted to use it again I completely forget how to set it up and had to Google for a few hours.
  7 | Hence this library which is (hopefully) as easy to use as MEF but with almost no setup required.
  8 | 
  9 | Enter `Galador.Reflection.Registry`
 10 | 
 11 | ## Basic Usage
 12 | First one can, optionally, register some service classes, either directly by name with `Register()`
 13 | or all service marked with `ExportAttribute` in a given assembly.
 14 | Note that one must register classes, not interfaces.
 15 | 
 16 |     var reg = new Registry();
 17 |     reg.Register<MyService>();
 18 |     reg.RegisterAssemblies(typeof(OtherService).Assembly);
 19 | 
 20 | Those service will be return when any super class or implemented interface is required.
 21 | 
 22 | Then one can use the registry as replacement for `Activator`, 
 23 | which will also do property and constructor injection.
 24 | 
 25 |     class A
 26 |     {
 27 |         // here svc will be resolve and obj will be created, if possible
 28 |         A(IOtherService svc, NotAService obj) { ... }
 29 | 
 30 |         [Import]
 31 |         public IService MyService { get; set; }
 32 |     }
 33 |     var a = reg.Create<A>();
 34 |     a.MyService.DoSomething();
 35 | 
 36 | 
 37 | One can also gain access to registered instance service by calling `Resolve()`
 38 | 
 39 |     var svc = reg.Resolve<IService>()
 40 |     var disposable = reg.ResolveAll<IDisposable>();
 41 | 
 42 | **Remark** If multiple service implement the same interface or are subclass of a common base class,
 43 |     `Resolve()` will return a `ResolveAll().First()` which is a random result in that case.
 44 | 
 45 | Finally one can always do the property injection anytime with
 46 | 
 47 |     var instance = ....
 48 |     reg.ResoleProperties(instance);
 49 | 
 50 | 
 51 | ## Functionality
 52 | If one ignore the multiple polymorphic version the registry (and related attributes) basically implement the following methods:
 53 | 
 54 |     [AttributeUsage(AttributeTargets.Class)]
 55 |     class ExportAttribute : Attribute {} // only use for RegisterAssemblies()
 56 | 
 57 |     [AttributeUsage(AttributeTargets.Property | AttributeTargets.Parameter)]
 58 |     class ImportAttribute : Attribute // for property / constructor injection
 59 |     {
 60 |         public Type ImportedType { get; set; } // if null, use paramter / property type
 61 |     }
 62 | 
 63 |     class Registry : IServiceProvider
 64 |     {
 65 |         // register services
 66 |         void RegisterAssemblies(exported type in assemblies)
 67 |         void Register(types);
 68 |         bool IsRegistered(type);
 69 | 
 70 |         // resolve (i.e. create only once in a call) any object
 71 |         T Resolve<T>();
 72 |         IEnumerable<T> ResolveAll<T>();
 73 | 
 74 |         // create: make a new one every time
 75 |         T Create<T>();
 76 |         bool CanCreate<T>();
 77 | 
 78 |         // bonus method: resolve property of existing instance
 79 |         void ResolveProperties(instance);
 80 |     }
 81 | 
 82 | **Service**
 83 | 
 84 | Service are class registered with the `Registry` and would be singleton when created by that `Registry`.
 85 | However Registry can resolve or create any class, not just service.
 86 | 
 87 | **Registering:**
 88 | 
 89 | The `Registry` maintains a keyed list of all registered service by type. 
 90 | Only one service can be registered against a particular class, however it will resolve for all base classes and 
 91 | implemented interfaces.
 92 | The service instance, if not provided at registration time, will be created the first time it is accessed 
 93 | and will be cached by the registry. Later request of that type will returned the same instance.
 94 | 
 95 | **Resolving:**
 96 | 
 97 | `Resolve()` will simply call `ResolveAll().First()`. `ResolveAll()` will look for all service implementing
 98 |     the requested class and/or interface. If none can be found it will `Create()` a new `T` if possible.
 99 | If the type is accessed for the first time, it will be created (with `Create()`) and its property will be injected
100 | (with `ResolveProperties()`), which might cause multiple recursive call to `Resolve()`.
101 | If multiple dependencies refer to the same type, an instance, saved in the `RequestCache` will be reused.
102 | 
103 | **Create:**
104 | 
105 | This will always create a **new** instance of the requested type. However all dependencies will be shared and reused as with `Resolve()`.
106 | `Create()` will always use the constructor with the most parameters that it can fill, creating them on demand if needed and possible.
107 | `ImportAttribute` can also be used on constructor parameter to specify a particular subclass or interface implementation.
108 | `ResolveProperties()`
109 | 
110 | **ExportAttribute**
111 | 
112 | This attribute is only used with `RegisterAssemblies()` to mark type that must be registered as service
113 | 
114 | **ImportAttribute**
115 | 
116 | This attribute is used to mark a dependency (that need not be a service). When an object is created all 
117 | its dependency are resolved and their dependencies and so on... One can use to specify a specific subclass to implement.
118 | 
119 |     class MyClass
120 |     {
121 |         MyClass([Import(typeof(SpecificService))]IService svc) { .. }
122 | 
123 |         [Import]
124 |         public LocationService Location { get; set; }
125 | 
126 |         public B B { get; set; }
127 |     }
128 |     class B 
129 |     {
130 |         [Import]
131 |         public MyClass MyClass { get; set; }
132 |     }
133 | 
134 | **Collections**
135 | 
136 | If an imported property (with `ImportAttribute`) is an `array[]` or an `IList<T>`, then `ResolveAll()` will 
137 | be used to initialize this property as an appropriately typed collection.
138 | 
139 | **Circular Reference**
140 | 
141 | If you use property injection (as opposed to constructor injection) circular reference (i.e. circular dependencies) will work just fine.
142 | 
143 | **Custom Initialization**
144 | 
145 | Once an object and its properties have been initialization, if it implements `IRegistryDelegate`, its method 
146 | `OnRegistryCreated()` will be called, for custom post creation initialization. All imported property will
147 | have been set when this method is called.
148 | 


--------------------------------------------------------------------------------
/Galador.Reflection/Utils/TypeTree.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Collections.Generic;
  3 | using System.Diagnostics;
  4 | using System.Linq;
  5 | using System.Reflection;
  6 | 
  7 | namespace Galador.Reflection.Utils
  8 | {
  9 |     public interface ITypeTree
 10 |     {
 11 |         int Count();
 12 |         int Count(Type root);
 13 |         IEnumerable<Type> GetKeys();
 14 |         IEnumerable<Type> GetKeys(Type root);
 15 |         void ClearValue(Type value);
 16 |         void Clear();
 17 |         bool ContainsKey(Type key);
 18 |     }
 19 | 
 20 |     public interface ITypeTree<TData> : ITypeTree
 21 |         where TData : class
 22 |     {
 23 |         TData this[Type key] { get; set; }
 24 |         IEnumerable<(Type key, TData value)> GetKeyValues();
 25 |         IEnumerable<(Type key, TData value)> GetKeyValues(Type root);
 26 |     }
 27 | 
 28 |     public class TypeTree<T> : ITypeTree<T>
 29 |         where T : class
 30 |     {
 31 |         [DebuggerDisplay("({Key.FullName}, {Data}, Descendants: {Descendants.Count})")]
 32 |         class TypeNode
 33 |         {
 34 |             public TypeNode(Type key)
 35 |             {
 36 |                 Key = key;
 37 |             }
 38 |             public readonly Type Key;
 39 |             public T Data;
 40 |             public readonly List<TypeNode> Descendants = new List<TypeNode>();
 41 | 
 42 |             public override string ToString() => $"{nameof(TypeNode)}({Key}, {Data}, Descendants: {Descendants.Count})";
 43 | 
 44 |             public int Count() => (Data == null ? 0 : 1) + Descendants.Select(x => x.Count()).Sum();
 45 | 
 46 |             public IEnumerable<Type> SubKeys
 47 |             {
 48 |                 get
 49 |                 {
 50 |                     if (Data != null)
 51 |                         yield return Key;
 52 |                     foreach (var d in Descendants)
 53 |                         foreach (var sub in d.SubKeys)
 54 |                             yield return sub;
 55 |                 }
 56 |             }
 57 |             public IEnumerable<(Type key, T value)> SubKeyValues
 58 |             {
 59 |                 get
 60 |                 {
 61 |                     if (Data != null)
 62 |                         yield return (Key, Data);
 63 |                     foreach (var d in Descendants)
 64 |                         foreach (var sub in d.SubKeyValues)
 65 |                             yield return sub;
 66 |                 }
 67 |             }
 68 |         }
 69 |         Dictionary<Type, TypeNode> nodes = new Dictionary<Type, TypeNode>();
 70 | 
 71 |         public TypeTree()
 72 |         {
 73 |         }
 74 | 
 75 |         public TypeTree(Func<Type, T, bool> validation)
 76 |         {
 77 |             Validation = validation;
 78 |         }
 79 | 
 80 |         public Func<Type, T, bool> Validation { get; }
 81 | 
 82 |         public void Validate(Type type, T data)
 83 |         {
 84 |             if (Validation == null)
 85 |                 return;
 86 |             if (!Validation(type, data))
 87 |                 throw new ArgumentException($"Invalid Data ({data}) for Key {type}", nameof(data));
 88 |         }
 89 | 
 90 |         public T this[Type key]
 91 |         {
 92 |             get
 93 |             {
 94 |                 if (nodes.TryGetValue(key, out var node))
 95 |                     return node.Data;
 96 |                 return null;
 97 |             }
 98 |             set
 99 |             {
100 |                 if (key == null)
101 |                     throw new ArgumentNullException(nameof(key));
102 |                 Validate(key, value);
103 |                 GetOrCreate(key).Data = value;
104 |             }
105 |         }
106 |         TypeNode GetOrCreate(Type key)
107 |         {
108 |             if (nodes.TryGetValue(key, out var node))
109 |                 return node;
110 | 
111 |             node = new TypeNode(key);
112 |             nodes[key] = node;
113 | 
114 |             var pi = key.GetTypeInfo();
115 | 
116 |             if (pi.BaseType != null)
117 |             {
118 |                 var pn = GetOrCreate(pi.BaseType);
119 |                 pn.Descendants.Add(node);
120 |             }
121 | 
122 |             foreach (var intfc in pi.ImplementedInterfaces)
123 |             {
124 |                 var pn = GetOrCreate(intfc);
125 |                 pn.Descendants.Add(node);
126 |             }
127 | 
128 |             // will happen for interfaces, but make sure everything is resolved by "object"
129 |             if (pi.BaseType == null && key != typeof(object))
130 |             {
131 |                 var pn = GetOrCreate(typeof(object));
132 |                 pn.Descendants.Add(node);
133 |             }
134 | 
135 |             return node;
136 |         }
137 | 
138 |         public void Clear() => nodes.Clear();
139 | 
140 |         public void ClearValue(Type value)
141 |         {
142 |             if (nodes.TryGetValue(value, out var node))
143 |                 node.Data = null;
144 |         }
145 | 
146 |         public bool ContainsKey(Type key) => nodes.TryGetValue(key, out var node) && node.Data != null;
147 | 
148 |         public int Count()
149 |         {
150 |             int n = 0;
151 |             foreach (var node in nodes.Values.Where(x => x.Data != null))
152 |                 n++;
153 |             return n;
154 |         }
155 | 
156 |         public IEnumerable<Type> GetKeys()
157 |         {
158 |             foreach (var node in nodes.Values.Where(x => x.Data != null))
159 |                 yield return node.Key;
160 |         }
161 | 
162 |         public IEnumerable<(Type key, T value)> GetKeyValues()
163 |         {
164 |             foreach (var node in nodes.Values.Where(x => x.Data != null))
165 |                 yield return (node.Key, node.Data);
166 |         }
167 | 
168 |         public int Count(Type root)
169 |         {
170 |             if (nodes.TryGetValue(root, out var node))
171 |                 return node.Count();
172 |             return 0;
173 |         }
174 | 
175 |         public IEnumerable<Type> GetKeys(Type root)
176 |         {
177 |             if (nodes.TryGetValue(root, out var node))
178 |                 foreach (var k in node.SubKeys)
179 |                     yield return k;
180 |         }
181 | 
182 |         public IEnumerable<(Type key, T value)> GetKeyValues(Type root)
183 |         {
184 |             if (nodes.TryGetValue(root, out var node))
185 |                 foreach (var kv in node.SubKeyValues)
186 |                     yield return kv;
187 |         }
188 |     }
189 | }
190 | 


--------------------------------------------------------------------------------
/Galador.Reflection/Serialization/IO/PrimitiveTextWriter.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Collections.Generic;
  3 | using System.Linq;
  4 | using System.IO;
  5 | using System.Text;
  6 | using System.Runtime.CompilerServices;
  7 | 
  8 | namespace Galador.Reflection.Serialization.IO
  9 | {
 10 |     enum TextPrimitiveSeparator
 11 |     {
 12 |         Space,
 13 |         NewLine,
 14 |         Tab,
 15 |         Comma,
 16 |     }
 17 | 
 18 |     /// <summary>
 19 |     /// An <see cref="IPrimitiveWriter"/> writing to a <see cref="TextWriter"/>.
 20 |     /// </summary>
 21 |     public class PrimitiveTextWriter : IPrimitiveWriter
 22 |     {
 23 | #pragma warning disable 1591 // XML Comments
 24 |         TextWriter Writer;
 25 | 
 26 |         public PrimitiveTextWriter(TextWriter writer)
 27 |         {
 28 |             if (writer == null)
 29 |                 throw new ArgumentNullException(nameof(writer));
 30 |             Writer = writer;
 31 |         }
 32 |         public void Dispose() { Writer.Dispose(); }
 33 | 
 34 |         internal TextPrimitiveSeparator Separator { get; set; } = TextPrimitiveSeparator.Space;
 35 | 
 36 |         [MethodImpl(MethodImplOptions.AggressiveInlining)]
 37 |         void WriteSeparator()
 38 |         {
 39 |             switch (Separator)
 40 |             {
 41 |                 default:
 42 |                 case TextPrimitiveSeparator.Space:
 43 |                     Writer.Write(' ');
 44 |                     break;
 45 |                 case TextPrimitiveSeparator.NewLine:
 46 |                     Writer.WriteLine();
 47 |                     break;
 48 |                 case TextPrimitiveSeparator.Tab:
 49 |                     Writer.Write('\t');
 50 |                     break;
 51 |                 case TextPrimitiveSeparator.Comma:
 52 |                     Writer.Write(", ");
 53 |                     break;
 54 |             }
 55 |         }
 56 | 
 57 |         public void Write(string value)
 58 |         {
 59 |             if (value == null)
 60 |             {
 61 |                 Writer.Write("null");
 62 |             }
 63 |             else
 64 |             {
 65 |                 Writer.Write('"');
 66 |                 foreach (var @char in value.Cast<char>())
 67 |                 {
 68 |                     switch (@char)
 69 |                     {
 70 |                         case '"':
 71 |                             Writer.Write("\\\"");
 72 |                             break;
 73 |                         case '\\':
 74 |                             Writer.Write("\\\\");
 75 |                             break;
 76 |                         default:
 77 |                             Writer.Write(@char);
 78 |                             break;
 79 |                     }
 80 |                 }
 81 |                 Writer.Write('"');
 82 |             }
 83 |             WriteSeparator();
 84 |         }
 85 | 
 86 |         public void Write(byte[] value)
 87 |         {
 88 |             if (value == null)
 89 |             {
 90 |                 Writer.Write("null");
 91 |             }
 92 |             else
 93 |             {
 94 |                 var s = Convert.ToBase64String(value);
 95 |                 Writer.Write('x');
 96 |                 Writer.Write(s);
 97 |             }
 98 |             WriteSeparator();
 99 |         }
100 | 
101 |         public void Write(Guid value)
102 |         {
103 |             var s = value.ToString();
104 |             Writer.Write(s);
105 |             WriteSeparator();
106 |         }
107 | 
108 |         public void Write(bool value)
109 |         {
110 |             Writer.Write(value ? "true" : "false");
111 |             WriteSeparator();
112 |         }
113 | 
114 |         public void Write(char value)
115 |         {
116 |             Write(new string(value, 1));
117 |         }
118 | 
119 |         public void Write(byte value)
120 |         {
121 |             Writer.Write(value.ToString("x"));
122 |             WriteSeparator();
123 |         }
124 | 
125 |         public void Write(sbyte value)
126 |         {
127 |             Writer.Write(value.ToString("x"));
128 |             WriteSeparator();
129 |         }
130 | 
131 |         public void Write(short value)
132 |         {
133 |             Writer.Write(value);
134 |             WriteSeparator();
135 |         }
136 | 
137 |         public void Write(ushort value)
138 |         {
139 |             Writer.Write(value);
140 |             WriteSeparator();
141 |         }
142 | 
143 |         public void Write(int value)
144 |         {
145 |             Writer.Write(value);
146 |             WriteSeparator();
147 |         }
148 | 
149 |         public void Write(uint value)
150 |         {
151 |             Writer.Write(value);
152 |             WriteSeparator();
153 |         }
154 | 
155 |         public void Write(long value)
156 |         {
157 |             Writer.Write(value);
158 |             WriteSeparator();
159 |         }
160 | 
161 |         public void Write(ulong value)
162 |         {
163 |             Writer.Write(value);
164 |             WriteSeparator();
165 |         }
166 | 
167 |         public void Write(float value)
168 |         {
169 |             Writer.Write(value.ToString("R"));
170 |             WriteSeparator();
171 |         }
172 | 
173 |         public void Write(double value)
174 |         {
175 |             Writer.Write(value.ToString("R"));
176 |             WriteSeparator();
177 |         }
178 | 
179 |         public void Write(decimal value)
180 |         {
181 |             Writer.Write(value);
182 |             WriteSeparator();
183 |         }
184 | 
185 |         public void WriteVInt(long value)
186 |         {
187 |             Writer.Write(value);
188 |             WriteSeparator();
189 |         }
190 | 
191 |         public void WriteVInt(ulong value)
192 |         {
193 |             Writer.Write(value);
194 |             WriteSeparator();
195 |         }
196 | 
197 |         public void WriteVInt(long? value)
198 |         {
199 |             if (value == null)
200 |             {
201 |                 Writer.Write("null");
202 |             }
203 |             else
204 |             {
205 |                 Writer.Write(value.Value);
206 |             }
207 |             WriteSeparator();
208 |         }
209 | 
210 |         public void WriteVInt(ulong? value)
211 |         {
212 |             if (value == null)
213 |             {
214 |                 Writer.Write("null");
215 |             }
216 |             else
217 |             {
218 |                 Writer.Write(value.Value);
219 |             }
220 |             WriteSeparator();
221 |         }
222 | #pragma warning restore 1591 // XML Comments
223 |     }
224 | }
225 | 


--------------------------------------------------------------------------------
/TestApp/TestForm.resx:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="utf-8"?>
  2 | <root>
  3 |   <!-- 
  4 |     Microsoft ResX Schema 
  5 |     
  6 |     Version 2.0
  7 |     
  8 |     The primary goals of this format is to allow a simple XML format 
  9 |     that is mostly human readable. The generation and parsing of the 
 10 |     various data types are done through the TypeConverter classes 
 11 |     associated with the data types.
 12 |     
 13 |     Example:
 14 |     
 15 |     ... ado.net/XML headers & schema ...
 16 |     <resheader name="resmimetype">text/microsoft-resx</resheader>
 17 |     <resheader name="version">2.0</resheader>
 18 |     <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
 19 |     <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
 20 |     <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
 21 |     <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
 22 |     <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
 23 |         <value>[base64 mime encoded serialized .NET Framework object]</value>
 24 |     </data>
 25 |     <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
 26 |         <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
 27 |         <comment>This is a comment</comment>
 28 |     </data>
 29 |                 
 30 |     There are any number of "resheader" rows that contain simple 
 31 |     name/value pairs.
 32 |     
 33 |     Each data row contains a name, and value. The row also contains a 
 34 |     type or mimetype. Type corresponds to a .NET class that support 
 35 |     text/value conversion through the TypeConverter architecture. 
 36 |     Classes that don't support this are serialized and stored with the 
 37 |     mimetype set.
 38 |     
 39 |     The mimetype is used for serialized objects, and tells the 
 40 |     ResXResourceReader how to depersist the object. This is currently not 
 41 |     extensible. For a given mimetype the value must be set accordingly:
 42 |     
 43 |     Note - application/x-microsoft.net.object.binary.base64 is the format 
 44 |     that the ResXResourceWriter will generate, however the reader can 
 45 |     read any of the formats listed below.
 46 |     
 47 |     mimetype: application/x-microsoft.net.object.binary.base64
 48 |     value   : The object must be serialized with 
 49 |             : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
 50 |             : and then encoded with base64 encoding.
 51 |     
 52 |     mimetype: application/x-microsoft.net.object.soap.base64
 53 |     value   : The object must be serialized with 
 54 |             : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
 55 |             : and then encoded with base64 encoding.
 56 | 
 57 |     mimetype: application/x-microsoft.net.object.bytearray.base64
 58 |     value   : The object must be serialized into a byte array 
 59 |             : using a System.ComponentModel.TypeConverter
 60 |             : and then encoded with base64 encoding.
 61 |     -->
 62 |   <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
 63 |     <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
 64 |     <xsd:element name="root" msdata:IsDataSet="true">
 65 |       <xsd:complexType>
 66 |         <xsd:choice maxOccurs="unbounded">
 67 |           <xsd:element name="metadata">
 68 |             <xsd:complexType>
 69 |               <xsd:sequence>
 70 |                 <xsd:element name="value" type="xsd:string" minOccurs="0" />
 71 |               </xsd:sequence>
 72 |               <xsd:attribute name="name" use="required" type="xsd:string" />
 73 |               <xsd:attribute name="type" type="xsd:string" />
 74 |               <xsd:attribute name="mimetype" type="xsd:string" />
 75 |               <xsd:attribute ref="xml:space" />
 76 |             </xsd:complexType>
 77 |           </xsd:element>
 78 |           <xsd:element name="assembly">
 79 |             <xsd:complexType>
 80 |               <xsd:attribute name="alias" type="xsd:string" />
 81 |               <xsd:attribute name="name" type="xsd:string" />
 82 |             </xsd:complexType>
 83 |           </xsd:element>
 84 |           <xsd:element name="data">
 85 |             <xsd:complexType>
 86 |               <xsd:sequence>
 87 |                 <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
 88 |                 <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
 89 |               </xsd:sequence>
 90 |               <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
 91 |               <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
 92 |               <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
 93 |               <xsd:attribute ref="xml:space" />
 94 |             </xsd:complexType>
 95 |           </xsd:element>
 96 |           <xsd:element name="resheader">
 97 |             <xsd:complexType>
 98 |               <xsd:sequence>
 99 |                 <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
100 |               </xsd:sequence>
101 |               <xsd:attribute name="name" type="xsd:string" use="required" />
102 |             </xsd:complexType>
103 |           </xsd:element>
104 |         </xsd:choice>
105 |       </xsd:complexType>
106 |     </xsd:element>
107 |   </xsd:schema>
108 |   <resheader name="resmimetype">
109 |     <value>text/microsoft-resx</value>
110 |   </resheader>
111 |   <resheader name="version">
112 |     <value>2.0</value>
113 |   </resheader>
114 |   <resheader name="reader">
115 |     <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
116 |   </resheader>
117 |   <resheader name="writer">
118 |     <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
119 |   </resheader>
120 |   <data name="richTextBox1.Text" xml:space="preserve">
121 |     <value>RQ Sci-Fi
122 | The Galaxy
123 | Inspirations
124 | ·	Star Wars &lt;http://starwars.wikia.com/wiki/Main_Page&gt; 
125 | ·	RuneQuest StarWar &lt;http://kurgan84.free.fr/RQ/RQ6StarWars.pdf&gt; but might disappear due to copyrighted material
126 | ·	RuneQuest Firearms &lt;http://www.thedesignmechanism.com/downloads.php&gt;
127 | ·	KOTOR &lt;http://en.wikipedia.org/wiki/Star_Wars:_Knights_of_the_Old_Republic&gt; 
128 | ·	Master of Orion II: http://en.wikipedia.org/wiki/Master_of_Orion_II:_Battle_at_Antares
129 | The Human sphere
130 | Most adventures happen in the human empire.
131 | </value>
132 |   </data>
133 | </root>


--------------------------------------------------------------------------------
/Galador.Reflection/Utils/PrimitiveType.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Collections.Generic;
  3 | using System.Text;
  4 | 
  5 | namespace Galador.Reflection.Utils
  6 | {
  7 |     // REMARK: works with KnownTypes.GetKind() & ObjectContext.WellKnownContext
  8 |     // it's why it starts at 1 (null is 0) and Decimal is expected to be last
  9 | 
 10 |     /// <summary>
 11 |     /// A quick categorization of .NET type
 12 |     /// </summary>
 13 |     public enum PrimitiveType : byte
 14 |     {
 15 |         /// <summary>
 16 |         /// array, pointers, and unsupported type will be none
 17 |         /// </summary>
 18 |         None = 0,
 19 |         /// <summary>
 20 |         /// Anything else that the obvious other values.
 21 |         /// </summary>
 22 |         Object,
 23 |         Type,
 24 | #pragma warning disable 1591 // XML Comments
 25 |         String,
 26 |         Bytes,
 27 |         Guid,
 28 |         Bool,
 29 |         Char,
 30 |         Byte,
 31 |         SByte,
 32 |         Int16,
 33 |         UInt16,
 34 |         Int32,
 35 |         UInt32,
 36 |         Int64,
 37 |         UInt64,
 38 |         Single,
 39 |         Double, 
 40 |         Decimal,
 41 | #pragma warning restore 1591 // XML Comments
 42 |     }
 43 | 
 44 |     /// <summary>
 45 |     /// Help convert between .NET type and the associated <see cref="PrimitiveType"/>
 46 |     /// </summary>
 47 |     public static class PrimitiveConverter
 48 |     {
 49 |         /// <summary>
 50 |         /// Whther this is a known structure or not.
 51 |         /// </summary>
 52 |         public static bool IsStruct(PrimitiveType type)
 53 |         {
 54 |             switch (type)
 55 |             {
 56 |                 default:
 57 |                 case PrimitiveType.None:
 58 |                 case PrimitiveType.Object:
 59 |                 case PrimitiveType.Type:
 60 |                 case PrimitiveType.String:
 61 |                 case PrimitiveType.Bytes:
 62 |                     return false;
 63 |                 case PrimitiveType.Guid:
 64 |                 case PrimitiveType.Bool:
 65 |                 case PrimitiveType.Char:
 66 |                 case PrimitiveType.Byte:
 67 |                 case PrimitiveType.SByte:
 68 |                 case PrimitiveType.Int16:
 69 |                 case PrimitiveType.UInt16:
 70 |                 case PrimitiveType.Int32:
 71 |                 case PrimitiveType.UInt32:
 72 |                 case PrimitiveType.Int64:
 73 |                 case PrimitiveType.UInt64:
 74 |                 case PrimitiveType.Single:
 75 |                 case PrimitiveType.Double:
 76 |                 case PrimitiveType.Decimal:
 77 |                     return true;
 78 |             }
 79 |         }
 80 | 
 81 |         /// <summary>
 82 |         /// Return the .NET <see cref="Type"/> for a <see cref="PrimitiveType"/>, or null in ambiguous case (<see cref="PrimitiveType.Object"/>).
 83 |         /// </summary>
 84 |         public static Type GetType(PrimitiveType type)
 85 |         {
 86 |             switch (type)
 87 |             {
 88 |                 default:
 89 |                 case PrimitiveType.None:
 90 |                 case PrimitiveType.Object:
 91 |                     return null;
 92 |                 case PrimitiveType.Type: return typeof(Type);
 93 |                 case PrimitiveType.String: return typeof(string);
 94 |                 case PrimitiveType.Bytes: return typeof(byte[]);
 95 |                 case PrimitiveType.Guid: return typeof(Guid);
 96 |                 case PrimitiveType.Bool: return typeof(bool);
 97 |                 case PrimitiveType.Char: return typeof(char);
 98 |                 case PrimitiveType.Byte: return typeof(byte);
 99 |                 case PrimitiveType.SByte: return typeof(sbyte);
100 |                 case PrimitiveType.Int16: return typeof(short);
101 |                 case PrimitiveType.UInt16: return typeof(ushort);
102 |                 case PrimitiveType.Int32: return typeof(int);
103 |                 case PrimitiveType.UInt32: return typeof(uint);
104 |                 case PrimitiveType.Int64: return typeof(long);
105 |                 case PrimitiveType.UInt64: return typeof(ulong);
106 |                 case PrimitiveType.Single: return typeof(float);
107 |                 case PrimitiveType.Double: return typeof(double);
108 |                 case PrimitiveType.Decimal: return typeof(decimal);
109 |             }
110 |         }
111 | 
112 |         /// <summary>
113 |         /// Return the <see cref="PrimitiveType"/> for .NET <see cref="Type"/>.
114 |         /// </summary>
115 |         public static PrimitiveType GetPrimitiveType(Type type)
116 |         {
117 |             if (type == null)
118 |                 throw new ArgumentNullException(nameof(type));
119 |             if (type == typeof(Type)) return PrimitiveType.Type;
120 |             if (type == typeof(string)) return PrimitiveType.String;
121 |             if (type == typeof(byte[])) return PrimitiveType.Bytes;
122 |             if (type == typeof(Guid)) return PrimitiveType.Guid;
123 |             if (type == typeof(bool)) return PrimitiveType.Bool;
124 |             if (type == typeof(char)) return PrimitiveType.Char;
125 |             if (type == typeof(byte)) return PrimitiveType.Byte;
126 |             if (type == typeof(sbyte)) return PrimitiveType.SByte;
127 |             if (type == typeof(short)) return PrimitiveType.Int16;
128 |             if (type == typeof(ushort)) return PrimitiveType.UInt16;
129 |             if (type == typeof(int)) return PrimitiveType.Int32;
130 |             if (type == typeof(uint)) return PrimitiveType.UInt32;
131 |             if (type == typeof(long)) return PrimitiveType.Int64;
132 |             if (type == typeof(ulong)) return PrimitiveType.UInt64;
133 |             if (type == typeof(float)) return PrimitiveType.Single;
134 |             if (type == typeof(double)) return PrimitiveType.Double;
135 |             if (type == typeof(decimal)) return PrimitiveType.Decimal;
136 |             return PrimitiveType.Object;
137 |         }
138 | 
139 |         public static string GetChsarpName(PrimitiveType type)
140 |         {
141 |             switch (type)
142 |             {
143 |                 default:
144 |                 case PrimitiveType.None:
145 |                 case PrimitiveType.Object:
146 |                     return "object";
147 |                 case PrimitiveType.Type: return "System.Type";
148 |                 case PrimitiveType.String: return "string";
149 |                 case PrimitiveType.Bytes: return "byte[]";
150 |                 case PrimitiveType.Guid: return "System.Guid";
151 |                 case PrimitiveType.Bool: return "bool";
152 |                 case PrimitiveType.Char: return "char";
153 |                 case PrimitiveType.Byte: return "byte";
154 |                 case PrimitiveType.SByte: return "sbyte";
155 |                 case PrimitiveType.Int16: return "short";
156 |                 case PrimitiveType.UInt16: return "ushort";
157 |                 case PrimitiveType.Int32: return "int";
158 |                 case PrimitiveType.UInt32: return "uint";
159 |                 case PrimitiveType.Int64: return "long";
160 |                 case PrimitiveType.UInt64: return "ulong";
161 |                 case PrimitiveType.Single: return "float";
162 |                 case PrimitiveType.Double: return "double";
163 |                 case PrimitiveType.Decimal: return "decimal";
164 |             }
165 |         }
166 |     }
167 | }
168 | 


--------------------------------------------------------------------------------
/Galador.Reflection/Serialization/IO/PrimitiveBinaryWriter.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Collections.Generic;
  3 | using System.IO;
  4 | using System.Text;
  5 | using System.Runtime.CompilerServices;
  6 | using Galador.Reflection.Utils;
  7 | using System.Runtime.InteropServices;
  8 | 
  9 | namespace Galador.Reflection.Serialization.IO
 10 | {
 11 |     // REMARK BitConverter follow Indianness, serializer should not, hopefully this will fix it
 12 |     [StructLayout(LayoutKind.Explicit)]
 13 |     struct Union8
 14 |     {
 15 |         [FieldOffset(0)]
 16 |         public char Char;
 17 |         [FieldOffset(0)]
 18 |         public long Int64;
 19 |         [FieldOffset(0)]
 20 |         public ulong UInt64;
 21 |         [FieldOffset(0)]
 22 |         public int Int32;
 23 |         [FieldOffset(0)]
 24 |         public uint UInt32;
 25 |         [FieldOffset(0)]
 26 |         public short Int16;
 27 |         [FieldOffset(0)]
 28 |         public ushort UInt16;
 29 |         [FieldOffset(0)]
 30 |         public float Single;
 31 |         [FieldOffset(0)]
 32 |         public double Double;
 33 | 
 34 |         [FieldOffset(0)]
 35 |         public byte Byte0;
 36 |         [FieldOffset(1)]
 37 |         public byte Byte1;
 38 |         [FieldOffset(2)]
 39 |         public byte Byte2;
 40 |         [FieldOffset(3)]
 41 |         public byte Byte3;
 42 |         [FieldOffset(4)]
 43 |         public byte Byte4;
 44 |         [FieldOffset(5)]
 45 |         public byte Byte5;
 46 |         [FieldOffset(6)]
 47 |         public byte Byte6;
 48 |         [FieldOffset(7)]
 49 |         public byte Byte7;
 50 |     }
 51 | 
 52 |     /// <summary>
 53 |     /// An <see cref="IPrimitiveWriter"/> writing to a <see cref="Stream"/>.
 54 |     /// </summary>
 55 |     public class PrimitiveBinaryWriter : IPrimitiveWriter
 56 |     {
 57 | #pragma warning disable 1591 // XML Comments
 58 |         Union8 union;
 59 |         Stream Stream;
 60 | 
 61 |         public PrimitiveBinaryWriter(Stream stream)
 62 |         {
 63 |             if (stream == null)
 64 |                 throw new ArgumentNullException(nameof(stream));
 65 |             Stream = stream;
 66 |         }
 67 |         public void Dispose() { Stream.Dispose(); }
 68 | 
 69 |         public void Write(string value)
 70 |         {
 71 |             byte[] buf = null;
 72 |             if (value != null)
 73 |             {
 74 |                 if (value.Length == 0)
 75 |                     buf = Array.Empty<byte>();
 76 |                 else
 77 |                     buf = Encoding.UTF8.GetBytes(value);
 78 |             }
 79 |             this.Write(buf);
 80 |         }
 81 | 
 82 |         public void Write(byte[] value)
 83 |         {
 84 |             var len = value == null ? (ulong?)null : (ulong)value.Length;
 85 |             Stream.WriteVNUInt(len);
 86 |             if (value != null && value.Length > 0)
 87 |             {
 88 |                 Stream.Write(value, 0, value.Length);
 89 |             }
 90 |         }
 91 | 
 92 |         public void Write(Guid value)
 93 |         {
 94 |             var buf = value.ToByteArray();
 95 |             Stream.Write(buf, 0, buf.Length);
 96 |         }
 97 | 
 98 |         public void Write(bool value)
 99 |         {
100 |             Stream.WriteByte(value ? (byte)1 : (byte)0);
101 |         }
102 | 
103 |         public void Write(char value)
104 |         {
105 |             union.Char = value;
106 |             Stream.WriteByte(union.Byte0);
107 |             Stream.WriteByte(union.Byte1);
108 |         }
109 | 
110 |         public void Write(byte value)
111 |         {
112 |             Stream.WriteByte(value);
113 |         }
114 | 
115 |         public void Write(sbyte value)
116 |         {
117 |             Stream.WriteByte(unchecked((byte)value));
118 |         }
119 | 
120 |         public void Write(short value)
121 |         {
122 |             union.Int16 = value;
123 |             Stream.WriteByte(union.Byte0);
124 |             Stream.WriteByte(union.Byte1);
125 |         }
126 | 
127 |         public void Write(ushort value)
128 |         {
129 |             union.UInt16 = value;
130 |             Stream.WriteByte(union.Byte0);
131 |             Stream.WriteByte(union.Byte1);
132 |         }
133 | 
134 |         public void Write(int value)
135 |         {
136 |             union.Int32 = value;
137 |             Stream.WriteByte(union.Byte0);
138 |             Stream.WriteByte(union.Byte1);
139 |             Stream.WriteByte(union.Byte2);
140 |             Stream.WriteByte(union.Byte3);
141 |         }
142 | 
143 |         public void Write(uint value)
144 |         {
145 |             union.UInt32 = value;
146 |             Stream.WriteByte(union.Byte0);
147 |             Stream.WriteByte(union.Byte1);
148 |             Stream.WriteByte(union.Byte2);
149 |             Stream.WriteByte(union.Byte3);
150 |         }
151 | 
152 |         public void Write(long value)
153 |         {
154 |             union.Int64 = value;
155 |             Stream.WriteByte(union.Byte0);
156 |             Stream.WriteByte(union.Byte1);
157 |             Stream.WriteByte(union.Byte2);
158 |             Stream.WriteByte(union.Byte3);
159 |             Stream.WriteByte(union.Byte4);
160 |             Stream.WriteByte(union.Byte5);
161 |             Stream.WriteByte(union.Byte6);
162 |             Stream.WriteByte(union.Byte7);
163 |         }
164 | 
165 |         public void Write(ulong value)
166 |         {
167 |             union.UInt64 = value;
168 |             Stream.WriteByte(union.Byte0);
169 |             Stream.WriteByte(union.Byte1);
170 |             Stream.WriteByte(union.Byte2);
171 |             Stream.WriteByte(union.Byte3);
172 |             Stream.WriteByte(union.Byte4);
173 |             Stream.WriteByte(union.Byte5);
174 |             Stream.WriteByte(union.Byte6);
175 |             Stream.WriteByte(union.Byte7);
176 |         }
177 | 
178 |         public void Write(float value)
179 |         {
180 |             union.Single = value;
181 |             Stream.WriteByte(union.Byte0);
182 |             Stream.WriteByte(union.Byte1);
183 |             Stream.WriteByte(union.Byte2);
184 |             Stream.WriteByte(union.Byte3);
185 |         }
186 | 
187 |         public void Write(double value)
188 |         {
189 |             union.Double = value;
190 |             Stream.WriteByte(union.Byte0);
191 |             Stream.WriteByte(union.Byte1);
192 |             Stream.WriteByte(union.Byte2);
193 |             Stream.WriteByte(union.Byte3);
194 |             Stream.WriteByte(union.Byte4);
195 |             Stream.WriteByte(union.Byte5);
196 |             Stream.WriteByte(union.Byte6);
197 |             Stream.WriteByte(union.Byte7);
198 |         }
199 | 
200 |         public void Write(decimal value)
201 |         {
202 |             var ii = decimal.GetBits(value);
203 |             Write(ii[0]);
204 |             Write(ii[1]);
205 |             Write(ii[2]);
206 |             Write(ii[3]);
207 |         }
208 | 
209 |         public void WriteVInt(long value)
210 |         {
211 |             Stream.WriteVInt(value);
212 |         }
213 | 
214 |         public void WriteVInt(ulong value)
215 |         {
216 |             Stream.WriteVUInt(value);
217 |         }
218 | 
219 |         public void WriteVInt(long? value)
220 |         {
221 |             Stream.WriteVNInt(value);
222 |         }
223 | 
224 |         public void WriteVInt(ulong? value)
225 |         {
226 |             Stream.WriteVNUInt(value);
227 |         }
228 | #pragma warning restore 1591 // XML Comments
229 |     }
230 | }
231 | 


--------------------------------------------------------------------------------
/Galador.Reflection/Serialization/IO/PrimitiveBinaryReader.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Collections.Generic;
  3 | using System.IO;
  4 | using System.Runtime.CompilerServices;
  5 | using System.Text;
  6 | using Galador.Reflection.Utils;
  7 | 
  8 | namespace Galador.Reflection.Serialization.IO
  9 | {
 10 |     /// <summary>
 11 |     /// An <see cref="IPrimitiveReader"/> reading from a <see cref="Stream"/>.
 12 |     /// </summary>
 13 |     public class PrimitiveBinaryReader : IPrimitiveReader
 14 |     {
 15 |         Union8 union;
 16 |         Stream Stream;
 17 |         byte[] buf16 = new byte[16];
 18 | 
 19 | #pragma warning disable 1591 // XML Comments
 20 | 
 21 |         public PrimitiveBinaryReader(Stream stream)
 22 |         {
 23 |             if (stream == null)
 24 |                 throw new ArgumentNullException(nameof(stream));
 25 |             this.Stream = stream;
 26 |         }
 27 |         public void Dispose() { Stream.Dispose(); }
 28 | 
 29 |         [MethodImpl(MethodImplOptions.AggressiveInlining)]
 30 |         void ReadWellKnownBytes(int n)
 31 |         {
 32 |             int pos = 0;
 33 |             while (pos < n)
 34 |             {
 35 |                 var nRead = Stream.Read(buf16, pos, n - pos);
 36 |                 if (nRead <= 0)
 37 |                     throw new IOException("EOF");
 38 |                 pos += nRead;
 39 |             }
 40 |         }
 41 | 
 42 |         public string ReadString()
 43 |         {
 44 |             var buf = this.ReadBytes();
 45 |             if (buf == null)
 46 |                 return null;
 47 |             if (buf.Length == 0)
 48 |                 return string.Empty;
 49 |             return Encoding.UTF8.GetString(buf, 0, buf.Length);
 50 |         }
 51 | 
 52 |         public byte[] ReadBytes()
 53 |         {
 54 |             var len = Stream.ReadVNUInt();
 55 |             if (len == null)
 56 |                 return null;
 57 |             if (len.Value == 0)
 58 |                 return Array.Empty<byte>();
 59 |             var buf = new byte[(int)len.Value];
 60 |             int pos = 0;
 61 |             while (pos < buf.Length)
 62 |             {
 63 |                 var nRead = Stream.Read(buf, pos, buf.Length - pos);
 64 |                 if (nRead <= 0)
 65 |                     throw new IOException("EOF");
 66 |                 pos += nRead;
 67 |             }
 68 |             return buf;
 69 |         }
 70 | 
 71 |         public Guid ReadGuid()
 72 |         {
 73 |             ReadWellKnownBytes(16);
 74 |             return new Guid(buf16);
 75 |         }
 76 | 
 77 |         public bool ReadBool()
 78 |         {
 79 |             var b = this.ReadByte();
 80 |             return b != 0;
 81 |         }
 82 | 
 83 |         public char ReadChar()
 84 |         {
 85 |             ReadWellKnownBytes(2);
 86 |             union.Byte0 = buf16[0];
 87 |             union.Byte1 = buf16[1];
 88 |             return union.Char;
 89 |         }
 90 | 
 91 |         public byte ReadByte()
 92 |         {
 93 |             var b = Stream.ReadByte();
 94 |             if (b < 0)
 95 |                 throw new IOException("EOF");
 96 |             return (byte)b;
 97 |         }
 98 | 
 99 |         public sbyte ReadSByte()
100 |         {
101 |             return unchecked((sbyte)this.ReadByte());
102 |         }
103 | 
104 |         public short ReadInt16()
105 |         {
106 |             ReadWellKnownBytes(2);
107 |             union.Byte0 = buf16[0];
108 |             union.Byte1 = buf16[1];
109 |             return union.Int16;
110 |         }
111 | 
112 |         public ushort ReadUInt16()
113 |         {
114 |             ReadWellKnownBytes(2);
115 |             union.Byte0 = buf16[0];
116 |             union.Byte1 = buf16[1];
117 |             return union.UInt16;
118 |         }
119 | 
120 |         public int ReadInt32()
121 |         {
122 |             ReadWellKnownBytes(4);
123 |             union.Byte0 = buf16[0];
124 |             union.Byte1 = buf16[1];
125 |             union.Byte2 = buf16[2];
126 |             union.Byte3 = buf16[3];
127 |             return union.Int32;
128 |         }
129 | 
130 |         public uint ReadUInt32()
131 |         {
132 |             ReadWellKnownBytes(4);
133 |             union.Byte0 = buf16[0];
134 |             union.Byte1 = buf16[1];
135 |             union.Byte2 = buf16[2];
136 |             union.Byte3 = buf16[3];
137 |             return union.UInt32;
138 |         }
139 | 
140 |         public long ReadInt64()
141 |         {
142 |             ReadWellKnownBytes(8);
143 |             union.Byte0 = buf16[0];
144 |             union.Byte1 = buf16[1];
145 |             union.Byte2 = buf16[2];
146 |             union.Byte3 = buf16[3];
147 |             union.Byte4 = buf16[4];
148 |             union.Byte5 = buf16[5];
149 |             union.Byte6 = buf16[6];
150 |             union.Byte7 = buf16[7];
151 |             return union.Int64;
152 |         }
153 | 
154 |         public ulong ReadUInt64()
155 |         {
156 |             ReadWellKnownBytes(8);
157 |             union.Byte0 = buf16[0];
158 |             union.Byte1 = buf16[1];
159 |             union.Byte2 = buf16[2];
160 |             union.Byte3 = buf16[3];
161 |             union.Byte4 = buf16[4];
162 |             union.Byte5 = buf16[5];
163 |             union.Byte6 = buf16[6];
164 |             union.Byte7 = buf16[7];
165 |             return union.UInt64;
166 |         }
167 | 
168 |         public float ReadSingle()
169 |         {
170 |             ReadWellKnownBytes(4);
171 |             union.Byte0 = buf16[0];
172 |             union.Byte1 = buf16[1];
173 |             union.Byte2 = buf16[2];
174 |             union.Byte3 = buf16[3];
175 |             return union.Single;
176 |         }
177 | 
178 |         public double ReadDouble()
179 |         {
180 |             ReadWellKnownBytes(8);
181 |             union.Byte0 = buf16[0];
182 |             union.Byte1 = buf16[1];
183 |             union.Byte2 = buf16[2];
184 |             union.Byte3 = buf16[3];
185 |             union.Byte4 = buf16[4];
186 |             union.Byte5 = buf16[5];
187 |             union.Byte6 = buf16[6];
188 |             union.Byte7 = buf16[7];
189 |             return union.Double;
190 |         }
191 | 
192 |         public decimal ReadDecimal()
193 |         {
194 |             ReadWellKnownBytes(16);
195 |             var parts = new int[4];
196 | 
197 |             union.Byte0 = buf16[0];
198 |             union.Byte1 = buf16[1];
199 |             union.Byte2 = buf16[2];
200 |             union.Byte3 = buf16[3];
201 |             parts[0] = union.Int32;
202 | 
203 |             union.Byte0 = buf16[4];
204 |             union.Byte1 = buf16[5];
205 |             union.Byte2 = buf16[6];
206 |             union.Byte3 = buf16[7];
207 |             parts[1] = union.Int32;
208 | 
209 |             union.Byte0 = buf16[8];
210 |             union.Byte1 = buf16[9];
211 |             union.Byte2 = buf16[10];
212 |             union.Byte3 = buf16[11];
213 |             parts[2] = union.Int32;
214 | 
215 |             union.Byte0 = buf16[12];
216 |             union.Byte1 = buf16[13];
217 |             union.Byte2 = buf16[14];
218 |             union.Byte3 = buf16[15];
219 |             parts[3] = union.Int32;
220 | 
221 |             return new decimal(parts);
222 |         }
223 | 
224 |         public long ReadVInt()
225 |         {
226 |             return Stream.ReadVInt();
227 |         }
228 | 
229 |         public ulong ReadVUInt()
230 |         {
231 |             return Stream.ReadVUInt();
232 |         }
233 | 
234 |         public long? ReadVNInt()
235 |         {
236 |             return Stream.ReadVNInt();
237 |         }
238 | 
239 |         public ulong? ReadVNUInt()
240 |         {
241 |             return Stream.ReadVNUInt();
242 |         }
243 | #pragma warning restore 1591 // XML Comments
244 |     }
245 | }
246 | 


--------------------------------------------------------------------------------
/TestAndroid/TestAndroid.csproj:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="utf-8"?>
  2 | <Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  3 |   <Import Project="..\packages\xunit.core.2.4.1\build\xunit.core.props" Condition="Exists('..\packages\xunit.core.2.4.1\build\xunit.core.props')" />
  4 |   <PropertyGroup>
  5 |     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
  6 |     <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
  7 |     <ProductVersion>8.0.30703</ProductVersion>
  8 |     <SchemaVersion>2.0</SchemaVersion>
  9 |     <ProjectGuid>{2FDE361C-3C2E-4FEB-B6E5-12EFFEB37F06}</ProjectGuid>
 10 |     <ProjectTypeGuids>{EFBA0AD7-5A72-4C68-AF49-83D382785DCF};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
 11 |     <OutputType>Library</OutputType>
 12 |     <AppDesignerFolder>Properties</AppDesignerFolder>
 13 |     <RootNamespace>TestAndroid</RootNamespace>
 14 |     <AssemblyName>TestAndroid</AssemblyName>
 15 |     <FileAlignment>512</FileAlignment>
 16 |     <AndroidApplication>true</AndroidApplication>
 17 |     <AndroidResgenFile>Resources\Resource.Designer.cs</AndroidResgenFile>
 18 |     <GenerateSerializationAssemblies>Off</GenerateSerializationAssemblies>
 19 |     <TargetFrameworkVersion>v11.0</TargetFrameworkVersion>
 20 |     <AndroidManifest>Properties\AndroidManifest.xml</AndroidManifest>
 21 |     <NuGetPackageImportStamp>
 22 |     </NuGetPackageImportStamp>
 23 |   </PropertyGroup>
 24 |   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
 25 |     <DebugSymbols>true</DebugSymbols>
 26 |     <DebugType>full</DebugType>
 27 |     <Optimize>false</Optimize>
 28 |     <OutputPath>bin\Debug\</OutputPath>
 29 |     <DefineConstants>DEBUG;TRACE</DefineConstants>
 30 |     <ErrorReport>prompt</ErrorReport>
 31 |     <WarningLevel>4</WarningLevel>
 32 |     <AndroidUseSharedRuntime>True</AndroidUseSharedRuntime>
 33 |     <AndroidLinkMode>None</AndroidLinkMode>
 34 |     <AotAssemblies>false</AotAssemblies>
 35 |     <EnableLLVM>false</EnableLLVM>
 36 |     <AndroidEnableProfiledAot>false</AndroidEnableProfiledAot>
 37 |     <BundleAssemblies>false</BundleAssemblies>
 38 |   </PropertyGroup>
 39 |   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
 40 |     <DebugType>pdbonly</DebugType>
 41 |     <Optimize>true</Optimize>
 42 |     <OutputPath>bin\Release\</OutputPath>
 43 |     <DefineConstants>TRACE</DefineConstants>
 44 |     <ErrorReport>prompt</ErrorReport>
 45 |     <WarningLevel>4</WarningLevel>
 46 |     <AndroidUseSharedRuntime>False</AndroidUseSharedRuntime>
 47 |     <AndroidLinkMode>SdkOnly</AndroidLinkMode>
 48 |   </PropertyGroup>
 49 |   <ItemGroup>
 50 |     <Reference Include="Microsoft.CSharp" />
 51 |     <Reference Include="Mono.Android" />
 52 |     <Reference Include="mscorlib" />
 53 |     <Reference Include="Newtonsoft.Json, Version=12.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
 54 |       <HintPath>..\packages\Newtonsoft.Json.12.0.3\lib\netstandard2.0\Newtonsoft.Json.dll</HintPath>
 55 |       <Private>True</Private>
 56 |     </Reference>
 57 |     <Reference Include="System" />
 58 |     <Reference Include="System.Core" />
 59 |     <Reference Include="System.IO.Compression" />
 60 |     <Reference Include="System.Net.Http" />
 61 |     <Reference Include="System.Xml.Linq" />
 62 |     <Reference Include="System.Xml" />
 63 |     <Reference Include="xunit.abstractions, Version=2.0.0.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
 64 |       <HintPath>..\packages\xunit.abstractions.2.0.3\lib\netstandard2.0\xunit.abstractions.dll</HintPath>
 65 |     </Reference>
 66 |     <Reference Include="xunit.assert, Version=2.4.1.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
 67 |       <HintPath>..\packages\xunit.assert.2.4.1\lib\netstandard1.1\xunit.assert.dll</HintPath>
 68 |     </Reference>
 69 |     <Reference Include="xunit.core, Version=2.4.1.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
 70 |       <HintPath>..\packages\xunit.extensibility.core.2.4.1\lib\netstandard1.1\xunit.core.dll</HintPath>
 71 |     </Reference>
 72 |     <Reference Include="xunit.execution.dotnet, Version=2.4.1.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
 73 |       <HintPath>..\packages\xunit.extensibility.execution.2.4.1\lib\netstandard1.1\xunit.execution.dotnet.dll</HintPath>
 74 |     </Reference>
 75 |   </ItemGroup>
 76 |   <ItemGroup>
 77 |     <Compile Include="..\TestApp\PathTests.cs">
 78 |       <Link>PathTests.cs</Link>
 79 |     </Compile>
 80 |     <Compile Include="..\TestApp\RegistryTests.cs">
 81 |       <Link>RegistryTests.cs</Link>
 82 |     </Compile>
 83 |     <Compile Include="..\TestApp\SerializerTests.cs">
 84 |       <Link>SerializerTests.cs</Link>
 85 |     </Compile>
 86 |     <Compile Include="..\TestApp\StreamTests.cs">
 87 |       <Link>StreamTests.cs</Link>
 88 |     </Compile>
 89 |     <Compile Include="MainActivity.cs" />
 90 |     <Compile Include="Resources\Resource.Designer.cs" />
 91 |     <Compile Include="Properties\AssemblyInfo.cs" />
 92 |     <Compile Include="TestAdapter.cs" />
 93 |   </ItemGroup>
 94 |   <ItemGroup>
 95 |     <None Include="packages.config" />
 96 |     <None Include="Resources\AboutResources.txt" />
 97 |     <AndroidResource Include="Resources\layout\LayoutTest.axml">
 98 |       <SubType>Designer</SubType>
 99 |     </AndroidResource>
100 |   </ItemGroup>
101 |   <ItemGroup>
102 |     <AndroidResource Include="Resources\layout\Main.axml">
103 |       <SubType>Designer</SubType>
104 |     </AndroidResource>
105 |   </ItemGroup>
106 |   <ItemGroup>
107 |     <AndroidResource Include="Resources\values\Strings.xml" />
108 |   </ItemGroup>
109 |   <ItemGroup>
110 |     <AndroidResource Include="Resources\drawable\Icon.png" />
111 |   </ItemGroup>
112 |   <ItemGroup>
113 |     <None Include="Properties\AndroidManifest.xml" />
114 |   </ItemGroup>
115 |   <ItemGroup>
116 |     <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
117 |   </ItemGroup>
118 |   <ItemGroup>
119 |     <ProjectReference Include="..\Galador.Reflection\Galador.Reflection.csproj">
120 |       <Project>{b7d89600-3529-498f-b11e-f9790846b442}</Project>
121 |       <Name>Galador.Reflection</Name>
122 |     </ProjectReference>
123 |   </ItemGroup>
124 |   <ItemGroup>
125 |     <Analyzer Include="..\packages\xunit.analyzers.0.10.0\analyzers\dotnet\cs\xunit.analyzers.dll" />
126 |   </ItemGroup>
127 |   <Import Project="$(MSBuildExtensionsPath)\Xamarin\Android\Xamarin.Android.CSharp.targets" />
128 |   <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
129 |     <PropertyGroup>
130 |       <ErrorText>This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
131 |     </PropertyGroup>
132 |     <Error Condition="!Exists('..\packages\xunit.core.2.4.1\build\xunit.core.props')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\xunit.core.2.4.1\build\xunit.core.props'))" />
133 |     <Error Condition="!Exists('..\packages\xunit.core.2.4.1\build\xunit.core.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\xunit.core.2.4.1\build\xunit.core.targets'))" />
134 |   </Target>
135 |   <Import Project="..\packages\xunit.core.2.4.1\build\xunit.core.targets" Condition="Exists('..\packages\xunit.core.2.4.1\build\xunit.core.targets')" />
136 |   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
137 |      Other similar extension points exist, see Microsoft.Common.targets.
138 | 		<Target Name="BeforeBuild">
139 | 		</Target>
140 | 		<Target Name="AfterBuild">
141 | 		</Target>
142 |  -->
143 | </Project>


--------------------------------------------------------------------------------
/Galador.Reflection/Serialization/IO/PrimitiveTextReader.cs:
--------------------------------------------------------------------------------
  1 | using Galador.Reflection.Utils;
  2 | using System;
  3 | using System.Collections.Generic;
  4 | using System.IO;
  5 | using System.Runtime.CompilerServices;
  6 | using System.Text;
  7 | 
  8 | namespace Galador.Reflection.Serialization.IO
  9 | {
 10 |     /// <summary>
 11 |     /// An <see cref="IPrimitiveReader"/> reading from a <see cref="TextReader"/>.
 12 |     /// </summary>
 13 |     public class PrimitiveTextReader : IPrimitiveReader
 14 |     {
 15 | #pragma warning disable 1591 // XML Comments
 16 |         TextReader Reader;
 17 | 
 18 |         public PrimitiveTextReader(TextReader reader)
 19 |         {
 20 |             if (reader == null)
 21 |                 throw new ArgumentNullException(nameof(reader));
 22 |             Reader = reader;
 23 |         }
 24 |         public void Dispose() { Reader.Dispose(); }
 25 | 
 26 |         #region ReadNextToken() ReadUntilNext()
 27 | 
 28 |         [MethodImpl(MethodImplOptions.AggressiveInlining)]
 29 |         string ReadNextToken()
 30 |         {
 31 |             var sb = new StringBuilder(32);
 32 |             var c = Reader.Peek();
 33 | 
 34 |             if (c == '"')
 35 |             {
 36 |                 Reader.Read();
 37 |                 var reading = true;
 38 |                 while (reading)
 39 |                 {
 40 |                     c = Reader.Read();
 41 |                     switch (c)
 42 |                     {
 43 |                         case -1:
 44 |                             throw new IOException("EOF");
 45 |                         case '\\':
 46 |                             var next = Reader.Read();
 47 |                             switch (next)
 48 |                             {
 49 |                                 case -1:
 50 |                                     throw new IOException("EOF");
 51 |                                 case '\\':
 52 |                                 case '"':
 53 |                                     sb.Append((char)next);
 54 |                                     break;
 55 |                                 default:
 56 |                                     throw new IOException("Invalid Token");
 57 |                             }
 58 |                             break;
 59 |                         case '"':
 60 |                             reading = false;
 61 |                             break;
 62 |                         default:
 63 |                             sb.Append((char)c);
 64 |                             break;
 65 |                     }
 66 |                 }
 67 |             }
 68 |             else
 69 |             {
 70 |                 while (true)
 71 |                 {
 72 |                     c = Reader.Peek();
 73 |                     if (c == -1)
 74 |                         throw new IOException("EOF");
 75 |                     if (c == ',' || char.IsWhiteSpace((char)c))
 76 |                         break;
 77 |                     Reader.Read();
 78 |                     sb.Append((char)c);
 79 |                 }
 80 |             }
 81 |             ReadUntilNext();
 82 |             return sb.Length > 0 ? sb.ToString() : "";
 83 |         } 
 84 | 
 85 |         [MethodImpl(MethodImplOptions.AggressiveInlining)]
 86 |         void ReadUntilNext()
 87 |         {
 88 |             int comma = 0;
 89 |             while (true)
 90 |             {
 91 |                 var c = Reader.Peek();
 92 |                 if (c == -1)
 93 |                     return;
 94 |                 if (char.IsWhiteSpace((char)c))
 95 |                 {
 96 |                     Reader.Read();
 97 |                 }
 98 |                 else if (comma == 0 && c == ',')
 99 |                 {
100 |                     comma++;
101 |                     Reader.Read();
102 |                 }
103 |                 else
104 |                 {
105 |                     return;
106 |                 }
107 |             }
108 |         }
109 | 
110 |         #endregion
111 | 
112 |         public string ReadString()
113 |         {
114 |             var p = Reader.Peek();
115 |             if (p < 0)
116 |                 throw new IOException("EOF");
117 |             var s = ReadNextToken();
118 |             if (p == '"')
119 |                 return s;
120 |             if (s == "null")
121 |                 return null;
122 |             throw new IOException("Invalid Token");
123 |         }
124 | 
125 |         public byte[] ReadBytes()
126 |         {
127 |             var s = ReadNextToken();
128 |             if (s == "null")
129 |                 return null;
130 |             if (!s.StartsWith("x"))
131 |                 throw new IOException("Invalid Token");
132 |             if (s.Length == 1)
133 |                 return Array.Empty<byte>();
134 |             return Convert.FromBase64String(s.Substring(1));
135 |         }
136 | 
137 |         public Guid ReadGuid()
138 |         {
139 |             var s = ReadNextToken();
140 |             return Guid.Parse(s);
141 |         }
142 | 
143 |         public bool ReadBool()
144 |         {
145 |             var s = ReadNextToken();
146 |             switch (s)
147 |             {
148 |                 case "true": return true;
149 |                 case "false": return false;
150 |                 default:
151 |                     throw new IOException("Invalid Token");
152 |             }
153 |         }
154 | 
155 |         public char ReadChar()
156 |         {
157 |             var s = ReadString();
158 |             return s[0];
159 |         }
160 | 
161 |         public byte ReadByte()
162 |         {
163 |             var s = ReadNextToken();
164 |             return byte.Parse(s, System.Globalization.NumberStyles.HexNumber);
165 |         }
166 | 
167 |         public sbyte ReadSByte()
168 |         {
169 |             return unchecked((sbyte)ReadByte());
170 |         }
171 | 
172 |         public short ReadInt16()
173 |         {
174 |             var s = ReadNextToken();
175 |             return short.Parse(s);
176 |         }
177 | 
178 |         public ushort ReadUInt16()
179 |         {
180 |             var s = ReadNextToken();
181 |             return ushort.Parse(s);
182 |         }
183 | 
184 |         public int ReadInt32()
185 |         {
186 |             var s = ReadNextToken();
187 |             return int.Parse(s);
188 |         }
189 | 
190 |         public uint ReadUInt32()
191 |         {
192 |             var s = ReadNextToken();
193 |             return uint.Parse(s);
194 |         }
195 | 
196 |         public long ReadInt64()
197 |         {
198 |             var s = ReadNextToken();
199 |             return long.Parse(s);
200 |         }
201 | 
202 |         public ulong ReadUInt64()
203 |         {
204 |             var s = ReadNextToken();
205 |             return ulong.Parse(s);
206 |         }
207 | 
208 |         public float ReadSingle()
209 |         {
210 |             var s = ReadNextToken();
211 |             return float.Parse(s);
212 |         }
213 | 
214 |         public double ReadDouble()
215 |         {
216 |             var s = ReadNextToken();
217 |             return double.Parse(s);
218 |         }
219 | 
220 |         public decimal ReadDecimal()
221 |         {
222 |             var s = ReadNextToken();
223 |             return decimal.Parse(s);
224 |         }
225 | 
226 |         public long ReadVInt()
227 |         {
228 |             return this.ReadInt64();
229 |         }
230 | 
231 |         public ulong ReadVUInt()
232 |         {
233 |             return this.ReadUInt64();
234 |         }
235 | 
236 |         public long? ReadVNInt()
237 |         {
238 |             var s = ReadNextToken();
239 |             if (s == "null")
240 |                 return null;
241 |             return long.Parse(s);
242 |         }
243 | 
244 |         public ulong? ReadVNUInt()
245 |         {
246 |             var s = ReadNextToken();
247 |             if (s == "null")
248 |                 return null;
249 |             return ulong.Parse(s);
250 |         }
251 | #pragma warning restore 1591 // XML Comments
252 |     }
253 | }
254 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | ## Galador.Reflection
  2 | [API Documentation](Galador.Reflection.chm?raw=true)
  3 | 
  4 | Here are a collection of reflection based multiplatform .NET utilities. The project is a VS2015 Community solution.
  5 | 
  6 | Using bait and switch trick there is only 1 DLL for each supported platforms, however the PCL DLL is used only at compile time and **should** not be used at runtime.
  7 | Use the **iOS**, **Android**, **.NET4.5** or **.NET Core** DLL instead.
  8 | 
  9 | Look in the test apps for additional usage sample.
 10 | 
 11 | ### Getting Started
 12 | 
 13 |     Install-Package Galador.Reflection
 14 | 
 15 | The package for  *PCL (iOS, Android, .NET)*, **iOS**, **Android**, **.NET4.5** has been published.
 16 | 
 17 | **REMARK** *.NET Core* support for now is only in source form. I could not properly name
 18 | the project and share the .NET Core source instead of duplicating them. 
 19 | However all test currently run successfully on .NET Core.
 20 | 
 21 | **REMARK** The source here is contained in a VS 2015 project. It is also required since I use some C# 6 and .NET 4.5 features.
 22 | One can download VS2015 for free [here](https://www.visualstudio.com/products/visual-studio-community-vs). 
 23 | 
 24 | **REMARK** The minimum .NET version supported is .NET4.5. There are so many little things which don't amount to much separately,
 25 | but all together will make porting it to earlier version of .NET just a pain I am not interested in.
 26 | 
 27 | 
 28 | ### Serializer
 29 | [Details](serializer.md)
 30 | 
 31 | A class which helps implement `File > Save` with very little setup. 
 32 | By design it ignores pointers, `IntPtr`, `Delegate`. Also it is designed to work with object that can fully be describe by their public fields and/or properties and, optionally by `IList` or `IDictionary` interfaces (generic or not).
 33 | And it will NOT restore private field / property, unless explicitly told to, with some attribute annotation on the class itself.
 34 | Very much like JSON value property / field are matched by name when deserializing. 
 35 | But unlike JSON default format this also store object as reference and save type information.
 36 | 
 37 | To serialize an object one does:
 38 | 
 39 |     var o = ....
 40 |     using var mem = new MemoryStream();
 41 |     using var writer = new PrimitiveBinaryWriter(mem);
 42 |     Serializer.Serialize(o, writer);
 43 | 
 44 | To deserialize an object one does
 45 | 
 46 |     using var mem = OpenFile();
 47 |     using var reader = new PrimitiveBinaryReader(mem);
 48 |     var o = Serializer.Deserialize(reader);
 49 | 
 50 | To serialize opaque type, such as a `Bitmap` one must create a surrogate class
 51 | 
 52 |     class BitmapSurrogate : ISurrogate<Bitmap>
 53 |     {
 54 |        public void Initialize(Bitmap bmp) { ... }
 55 |        public Bitmap Instantiate() { ... }
 56 | 
 57 |        // data now exposed as public supported property, hence can be serialized
 58 |        public byte[] Data { get; set; }
 59 |     }
 60 | 
 61 | 
 62 | Finally if provided with a stream created by a third party with this Serializer, one can use `ObjectContext.GenerateCSharpCode()` 
 63 | or `Serializer.GenerateCSharpCode()` to generate a class hierarchy that can be used to deserialize the stream.
 64 | 
 65 | 
 66 | ### Registry
 67 | [Details](registry.md)
 68 | 
 69 | An IoC container, `IServiceProvider`, MEF clone all in one.
 70 | 
 71 | First create an instance of a registry `var registry = new Registry()`
 72 | 
 73 | Service class are then registered with `registry.Register<T>()` or all of those marked with `ExportAttribute` via `registry.RegisterAssemblies(...)`.
 74 | Remark class (not interface) class should be registered. They could then be access though **any** type or interface they implement.
 75 | 
 76 | After service registration it can be use as a replacement for the `Activator` class, 
 77 | it will also do constructor injection (using the constructor with the most parameters) 
 78 | and property injection, when a property is marked with `ImportAttribute`. 
 79 | The injection will use all the interfaces registered previously, or create instances on demand recursively.
 80 | 
 81 | Finally to solve mutually dependent object implement `IRegistryDelegate` such as
 82 | 
 83 |     class A : IRegistryDelegate
 84 |     {
 85 |         [Import]
 86 |         public B B { get; set; }
 87 | 
 88 |         void IRegistryDelegate.OnRegistryCreated() {
 89 |             B.DoSomething();
 90 |         }
 91 |     }
 92 | 
 93 |     class B
 94 |     {
 95 |         [Import]
 96 |         public A A{ set; set; }
 97 | 
 98 |         public void DoSomething() { ... }
 99 |     }
100 |     var registry = new Registry();
101 |     var a = registry.Resolve<A>();
102 | 
103 | 
104 | 
105 | ### PropertyPath
106 | An handy little utility to observe property path, help synchronize POCO class as much as  WPF does with binding.
107 | It also register weak event so one should keep a handler to it to keep it alive.
108 | It watches `INotifyPropertyChange` interface for change, so it is better used with MVVM data models.
109 | 
110 | Here is a simple use case, of registering an event when a property changes:
111 | 
112 |     void SetModel(Model m)
113 |     {
114 |         modelWatcher = PropertyPath.Watch(m, x => x.Location.City, city => {
115 |             this.City = city;
116 |         });
117 |     }
118 |     PropertyPath modelWatcher;
119 | 
120 | 
121 | ### FastType
122 | Unfortunately, even in 2016! .NET reflection has pitiful performance. `FastType` provide
123 | quick (default) constructor and member getter and setter on platform that support 
124 | [System.Emit](https://docs.microsoft.com/en-us/dotnet/core/api/system.reflection.emit),
125 | (i.e. full .NET framework and .NET core, but not Android/iOS) falling back on normal reflection otherwise.
126 | 
127 | Example:
128 | 
129 |     var FT = FastType.GetType(typeof(List<object>));
130 |     var list = FT.TryConstruct();
131 |     FT.DeclaredMembers["Capacity"].SetValue(list, 42);
132 | 
133 |     // same as
134 |     var list = new List<object>();
135 |     list.Capacity = 42;
136 | 
137 | 
138 | ### TraceKeys
139 | 
140 | This is one of my utility which only happen to be here for convenience.
141 | It is a thin multiplatform wrapper around [System.Diagnostics.Trace](https://docs.microsoft.com/en-us/dotnet/core/api/system.diagnostics.trace#System_Diagnostics_Trace)
142 | with the added benefit that whole traces can be turned on or off at once *easily* (with `TraceKey.IsEnabled`).
143 | Hence all TraceListeners apply to it (when the key is enabled).
144 | 
145 | One get a `TraceKey` with `TraceKeys.Traces[name]` or use an already defined one such
146 | as `TraceKeys.Application`. Then call any of its method to log something.
147 | All methods but `TraceKey.Write()` and `TraceKey.WriteLine()` will start the output line with `TraceKey.Header`
148 | which by default contains the trace name, current date time and thread id.
149 | 
150 | By default all `TraceKey` are disabled (except `TraceKeys.Application`). On the desktop (full .NET framework)
151 | they will automatically pick up the `AppSettings` values for `"TraceKeys." + key.Name`
152 | (text value must be in `"true" "false" "0" "1" "on" "off" "enable" "disable"`).
153 | 
154 | Examples:
155 | 
156 |     // enable Serializer logging
157 |     // with AppSettings
158 |     <add key="TraceKeys.Serialization" value="true"/>
159 |     // with code
160 |     TraceKeys.Serialization.IsEnabled = true;
161 | 
162 |     // use your own key
163 |     public static readonly LogData = TraceKeys.Traces[$"{nameof(Model)} {nameof(LogData)}"];
164 |     // or
165 |     public static readonly LogData = TraceKeys.Traces.GetTrace("Model LogData", t => t.IsEnabled = true);
166 | 
167 |     // enable it with AppSettings
168 |     <add key="TraceKeys.Model LogData" value="on"/>
169 | 
170 |     // use it
171 |     LogData.WriteLine(data);
172 |     LogData.Information("all good")
173 |     LogData.Error(exception);
174 | 
175 |     // enable all traces with code
176 |     foreach (var trace in TraceKeys.Traces)
177 |         trace.IsEnabled = true;


--------------------------------------------------------------------------------
/Galador.Reflection/Serialization/SerializationAttributes.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Collections.Generic;
  3 | using System.Reflection;
  4 | using System.Text;
  5 | 
  6 | namespace Galador.Reflection.Serialization
  7 | {
  8 |     /// <summary>
  9 |     /// Attribute that control serialization behavior for a particular type.
 10 |     /// </summary>
 11 |     [AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Interface | AttributeTargets.Enum, AllowMultiple = false, Inherited = false)]
 12 |     public class SerializationSettingsAttribute : Attribute
 13 |     {
 14 |         /// <summary>
 15 |         /// Initializes a new instance of the <see cref="SerializationSettingsAttribute"/> class.
 16 |         /// </summary>
 17 |         public SerializationSettingsAttribute()
 18 |         {
 19 |         }
 20 |         readonly internal static SerializationSettingsAttribute Defaults = new SerializationSettingsAttribute();
 21 | 
 22 |         /// <summary>
 23 |         /// Initializes a new instance of the <see cref="SerializationSettingsAttribute"/> class.
 24 |         /// </summary>
 25 |         /// <param name="default">Set all properties to <paramref name="default"/>.</param>
 26 |         public SerializationSettingsAttribute(bool @default)
 27 |         {
 28 |             IncludePublicProperties = @default;
 29 |             IncludePrivateProperties = @default;
 30 |             IncludePublicFields = @default;
 31 |             IncludePrivateFields = @default;
 32 |             IncludeListInterface = @default;
 33 |             IncludeDictionaryInterface = @default;
 34 |         }
 35 | 
 36 |         /// <summary>
 37 |         /// Whether public properties of this type should be serialized or not. Default value is <c>true</c>.
 38 |         /// </summary>
 39 |         public bool IncludePublicProperties { get; set; } = true;
 40 | 
 41 |         /// <summary>
 42 |         /// Whether private properties of this type should be serialized or not. Default value is <c>false</c>.
 43 |         /// </summary>
 44 |         public bool IncludePrivateProperties { get; set; } = false;
 45 | 
 46 |         /// <summary>
 47 |         /// Whether public fields of this type should be serialized or not. Default value is <c>true</c>.
 48 |         /// </summary>
 49 |         public bool IncludePublicFields { get; set; } = true;
 50 | 
 51 |         /// <summary>
 52 |         /// Whether private fields of this type should be serialized or not. Default value is <c>false</c>.
 53 |         /// </summary>
 54 |         public bool IncludePrivateFields { get; set; } = false;
 55 | 
 56 |         /// <summary>
 57 |         /// Include items from <see cref="System.Collections.IList"/> and <see cref="IList{T}"/> interface
 58 |         /// </summary>
 59 |         public bool IncludeListInterface { get; set; } = true;
 60 | 
 61 |         /// <summary>
 62 |         /// Include items from <see cref="System.Collections.IDictionary"/> and <see cref="IDictionary{TKey, TValue}"/> interface
 63 |         /// </summary>
 64 |         public bool IncludeDictionaryInterface { get; set; } = true;
 65 | 
 66 |         /// <summary>
 67 |         /// Will get or set whether public properties AND public fields of this type must be serialized.
 68 |         /// </summary>
 69 |         public bool IncludePublics
 70 |         {
 71 |             get { return IncludePublicFields && IncludePublicProperties; }
 72 |             set
 73 |             {
 74 |                 IncludePublicProperties = value;
 75 |                 IncludePublicFields = value;
 76 |             }
 77 |         }
 78 | 
 79 |         /// <summary>
 80 |         /// Will get or set whether private properties AND private fields of this type must be serialized.
 81 |         /// </summary>
 82 |         public bool IncludePrivates
 83 |         {
 84 |             get { return IncludePrivateFields && IncludePrivateProperties; }
 85 |             set
 86 |             {
 87 |                 IncludePrivateFields = value;
 88 |                 IncludePrivateProperties = value;
 89 |             }
 90 |         }
 91 | 
 92 |         /// <summary>
 93 |         /// Will get or set whether all properties of this type (whether public or private) must be serialized.
 94 |         /// </summary>
 95 |         public bool IncludeProperties
 96 |         {
 97 |             get { return IncludePublicProperties && IncludePrivateProperties; }
 98 |             set
 99 |             {
100 |                 IncludePublicProperties = value;
101 |                 IncludePrivateProperties = value;
102 |             }
103 |         }
104 | 
105 |         /// <summary>
106 |         /// Will get or set whether all fields of this type (whether public or private) must be serialized.
107 |         /// </summary>
108 |         public bool IncludeFields
109 |         {
110 |             get { return IncludePrivateFields && IncludePublicFields; }
111 |             set
112 |             {
113 |                 IncludePrivateFields = value;
114 |                 IncludePublicFields = value;
115 |             }
116 |         }
117 |     }
118 | 
119 |     /// <summary>
120 |     /// This attribute will override default type name and assembly name used to identify the type they decorate.
121 |     /// </summary>
122 |     [AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Interface | AttributeTargets.Enum, AllowMultiple = false, Inherited = false)]
123 |     public class SerializationNameAttribute : Attribute
124 |     {
125 |         /// <summary>
126 |         /// Initializes a new instance of the <see cref="SerializationNameAttribute"/> class.
127 |         /// </summary>
128 |         public SerializationNameAttribute()
129 |         {
130 |         }
131 |         /// <summary>
132 |         /// Initializes a new instance of the <see cref="SerializationNameAttribute"/> class.
133 |         /// </summary>
134 |         /// <param name="type">The <see cref="FullName"/> to use.</param>
135 |         /// <param name="assembly">The <see cref="AssemblyName"/> to use.</param>
136 |         public SerializationNameAttribute(string type, string assembly = null)
137 |         {
138 |             if (type == null)
139 |                 throw new ArgumentNullException($"parameter {type} should not be null.");
140 |             FullName = type;
141 |             AssemblyName = assembly;
142 |         }
143 | 
144 |         /// <summary>
145 |         /// Value to use in lieu of the <see cref="Type.FullName"/>
146 |         /// </summary>
147 |         public string FullName { get; set; }
148 |         /// <summary>
149 |         /// Value to use in lieu of the <see cref="System.Reflection.AssemblyName.Name"/>.
150 |         /// </summary>
151 |         public string AssemblyName { get; set; }
152 | 
153 |         /// <summary>
154 |         /// Determines <paramref name="obj"/> is another <see cref="SerializationNameAttribute"/> with the same property values.
155 |         /// </summary>
156 |         /// <param name="obj">The <see cref="System.Object" /> to compare with this instance.</param>
157 |         /// <returns>
158 |         ///   <c>true</c> if the specified <see cref="System.Object" /> is equal to this instance; otherwise, <c>false</c>.
159 |         /// </returns>
160 |         public override bool Equals(object obj)
161 |         {
162 |             var o = obj as SerializationNameAttribute;
163 |             if (o == null)
164 |                 return false;
165 |             return FullName == o.FullName && AssemblyName == o.AssemblyName;
166 |         }
167 |         /// <summary>
168 |         /// Returns a hash code for this instance.
169 |         /// </summary>
170 |         /// <returns>
171 |         /// A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table. 
172 |         /// </returns>
173 |         public override int GetHashCode()
174 |         {
175 |             return (FullName ?? "").GetHashCode()
176 |                 ^ (AssemblyName ?? "").GetHashCode();
177 |         }
178 | 
179 |         public override string ToString() => $"SerializationName({FullName}, {AssemblyName})";
180 |     }
181 | 
182 |     [AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Interface | AttributeTargets.Enum, AllowMultiple = false, Inherited = false)]
183 |     public class SerializationGuidAttribute : SerializationNameAttribute
184 |     {
185 |         public SerializationGuidAttribute(string guid)
186 |             : base(guid)
187 |         {
188 |             Guid.Parse(guid);
189 |         }
190 |     }
191 | 
192 |     [AttributeUsage(AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false, Inherited = false)]
193 |     public class SerializationMemberNameAttribute : Attribute
194 |     {
195 |         public SerializationMemberNameAttribute()
196 |         {
197 |         }
198 |         public SerializationMemberNameAttribute(string name)
199 |         {
200 |             if (string.IsNullOrEmpty(name))
201 |                 throw new ArgumentNullException($"parameter {name} should not be null.");
202 |             MemberName = name;
203 |         }
204 | 
205 |         public string MemberName { get; set; }
206 | 
207 |         /// <summary>
208 |         /// Determines <paramref name="obj"/> is another <see cref="SerializationNameAttribute"/> with the same property values.
209 |         /// </summary>
210 |         /// <param name="obj">The <see cref="System.Object" /> to compare with this instance.</param>
211 |         /// <returns>
212 |         ///   <c>true</c> if the specified <see cref="System.Object" /> is equal to this instance; otherwise, <c>false</c>.
213 |         /// </returns>
214 |         public override bool Equals(object obj)
215 |         {
216 |             var o = obj as SerializationMemberNameAttribute;
217 |             if (o == null)
218 |                 return false;
219 |             return MemberName == o.MemberName;
220 |         }
221 |         /// <summary>
222 |         /// Returns a hash code for this instance.
223 |         /// </summary>
224 |         /// <returns>
225 |         /// A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table. 
226 |         /// </returns>
227 |         public override int GetHashCode() => MemberName?.GetHashCode() ?? 0;
228 |     }
229 | 
230 |     /// <summary>
231 |     /// Property or Field with this attribute will be serialized regardless of the <see cref="SerializationSettingsAttribute"/> of their class.
232 |     /// </summary>
233 |     [AttributeUsage(AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false, Inherited = false)]
234 |     public class SerializedAttribute : Attribute
235 |     {
236 |     }
237 | 
238 |     /// <summary>
239 |     /// Property or Field with this attribute will NOT be serialized regardless of the <see cref="SerializationSettingsAttribute"/> of their class.
240 |     /// </summary>
241 |     [AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Class, AllowMultiple = false, Inherited = false)]
242 |     public class NotSerializedAttribute : Attribute
243 |     {
244 |     }
245 | }
246 | 


--------------------------------------------------------------------------------
/Galador.Reflection/Serialization/Writer.cs:
--------------------------------------------------------------------------------
  1 | using Galador.Reflection.Serialization.IO;
  2 | using Galador.Reflection.Utils;
  3 | using System;
  4 | using System.Collections;
  5 | using System.Collections.Generic;
  6 | using System.Diagnostics;
  7 | using System.Linq;
  8 | using System.Text;
  9 | using SRS = System.Runtime.Serialization;
 10 | 
 11 | namespace Galador.Reflection.Serialization
 12 | {
 13 |     public class Writer : Context, IDisposable
 14 |     {
 15 |         readonly IPrimitiveWriter output;
 16 | 
 17 |         public Writer(IPrimitiveWriter output)
 18 |         {
 19 |             this.output = output ?? throw new ArgumentNullException(nameof(output));
 20 |             output.WriteVInt(VERSION);
 21 |         }
 22 | 
 23 |         // v2, whole new Serializer classes
 24 |         const ulong VERSION = 0x01_02;
 25 | 
 26 |         public void Dispose()
 27 |         {
 28 |             output.Dispose();
 29 |         }
 30 | 
 31 |         public SerializationSettings Settings
 32 |         {
 33 |             get
 34 |             {
 35 |                 if (settings == null)
 36 |                     settings = new SerializationSettings();
 37 |                 return settings;
 38 |             }
 39 |             set { settings = value; }
 40 |         }
 41 |         SerializationSettings settings;
 42 | 
 43 |         public void Write(object o)
 44 |         {
 45 |             if (writeRecurseDepth++ == 0)
 46 |             {
 47 |                 var sFlags = Settings.ToFlags();
 48 |                 output.WriteVInt(sFlags);
 49 |             }
 50 |             try
 51 |             {
 52 |                 Write(RObject, o);
 53 |             }
 54 |             finally { writeRecurseDepth--; }
 55 |         }
 56 |         int writeRecurseDepth = 0;
 57 | 
 58 |         internal void Write(RuntimeType expected, object value)
 59 |         {
 60 |             value = AsMetaData(value);
 61 | 
 62 |             // write id, continue if first time
 63 |             if (expected.IsReference)
 64 |             {
 65 |                 if (TryGetId(value, out var id))
 66 |                 {
 67 |                     output.WriteVInt(id);
 68 |                     return;
 69 |                 }
 70 |                 id = NewId();
 71 |                 Register(id, value);
 72 |                 output.WriteVInt(id);
 73 |             }
 74 | 
 75 |             // write class info if needed
 76 |             var actual = expected;
 77 |             if (expected.IsReference && !expected.IsSealed)
 78 |             {
 79 |                 actual = RuntimeType.GetType(value);
 80 |                 Write(RType, actual);
 81 |             }
 82 | 
 83 |             // only proceed further if value is supported
 84 |             if (!expected.IsSupported || !actual.IsSupported)
 85 |                 return;
 86 | 
 87 |             // dispatch to the appropriate write method
 88 |             if (actual.Surrogate != null)
 89 |             {
 90 |                 Write(RObject, actual.Surrogate.Convert(value));
 91 |             }
 92 |             else if (actual.Converter != null && !settings.IgnoreTypeConverter)
 93 |             {
 94 |                 WriteConverter(actual, value);
 95 |             }
 96 |             else if (actual.IsISerializable && !Settings.IgnoreISerializable)
 97 |             {
 98 |                 WriteISerializable(value);
 99 |             }
100 |             else
101 |             {
102 |                 switch (actual.Kind)
103 |                 {
104 |                     default:
105 |                     case PrimitiveType.None:
106 |                         throw new InvalidOperationException("shouldn't be there");
107 |                     case PrimitiveType.Object:
108 |                         if (actual.IsArray)
109 |                         {
110 |                             WriteArray(actual, value);
111 |                         }
112 |                         else if (actual.IsNullable)
113 |                         {
114 |                             if (value == null) output.Write(false);
115 |                             else
116 |                             {
117 |                                 output.Write(true);
118 |                                 Write(actual.GenericParameters[0], value);
119 |                             }
120 |                         }
121 |                         else if (actual.IsEnum)
122 |                         {
123 |                             Write(actual.Element, value);
124 |                         }
125 |                         else
126 |                         {
127 |                             WriteObject(actual, value);
128 |                         }
129 |                         break;
130 |                     case PrimitiveType.Type:
131 |                         ((TypeData)value).Write(this, output);
132 |                         break;
133 |                     case PrimitiveType.String:
134 |                         output.Write((string)value);
135 |                         break;
136 |                     case PrimitiveType.Bytes:
137 |                         output.Write((byte[])value);
138 |                         break;
139 |                     case PrimitiveType.Guid:
140 |                         output.Write((Guid)value);
141 |                         break;
142 |                     case PrimitiveType.Bool:
143 |                         output.Write((bool)value);
144 |                         break;
145 |                     case PrimitiveType.Char:
146 |                         output.Write((char)value);
147 |                         break;
148 |                     case PrimitiveType.Byte:
149 |                         output.Write((byte)value);
150 |                         break;
151 |                     case PrimitiveType.SByte:
152 |                         output.Write((sbyte)value);
153 |                         break;
154 |                     case PrimitiveType.Int16:
155 |                         output.Write((short)value);
156 |                         break;
157 |                     case PrimitiveType.UInt16:
158 |                         output.Write((ushort)value);
159 |                         break;
160 |                     case PrimitiveType.Int32:
161 |                         output.Write((int)value);
162 |                         break;
163 |                     case PrimitiveType.UInt32:
164 |                         output.Write((uint)value);
165 |                         break;
166 |                     case PrimitiveType.Int64:
167 |                         output.Write((long)value);
168 |                         break;
169 |                     case PrimitiveType.UInt64:
170 |                         output.Write((ulong)value);
171 |                         break;
172 |                     case PrimitiveType.Single:
173 |                         output.Write((float)value);
174 |                         break;
175 |                     case PrimitiveType.Double:
176 |                         output.Write((double)value);
177 |                         break;
178 |                     case PrimitiveType.Decimal:
179 |                         output.Write((decimal)value);
180 |                         break;
181 |                 }
182 |             }
183 |         }
184 | 
185 |         void WriteArray(RuntimeType type, object value)
186 |         {
187 |             var array = (Array)value;
188 |             if (array.Rank != type.ArrayRank)
189 |                 throw new ArgumentException($"{array} Rank is {array.Rank} instead of expected {type.ArrayRank}");
190 |             for (int i = 0; i < type.ArrayRank; i++)
191 |                 output.WriteVInt(array.GetLength(i));
192 |             foreach (var item in array)
193 |                 Write(type.Element, item);
194 |         }
195 | 
196 |         void WriteISerializable(object value)
197 |         {
198 |             var serial = (SRS.ISerializable)value;
199 |             var info = new SRS.SerializationInfo(typeof(object), new SRS.FormatterConverter());
200 |             var ctx = new SRS.StreamingContext(SRS.StreamingContextStates.Persistence);
201 |             serial.GetObjectData(info, ctx);
202 |             output.WriteVInt(info.MemberCount);
203 |             foreach (var item in info)
204 |             {
205 |                 Write(RString, item.Name);
206 |                 Write(RObject, item.Value);
207 |             }
208 |         }
209 | 
210 |         void WriteConverter(RuntimeType type, object value)
211 |         {
212 |             var s = type.Converter.ConvertToInvariantString(value);
213 |             Write(RString, s);
214 |         }
215 | 
216 |         void WriteObject(RuntimeType type, object value)
217 |         {
218 |             foreach (var m in type.RuntimeMembers)
219 |             {
220 |                 var p = m.RuntimeMember.GetValue(value);
221 |                 Write(m.Type, p);
222 |             }
223 | 
224 |             switch (type.CollectionType)
225 |             {
226 |                 case RuntimeCollectionType.IDictionaryKV:
227 |                     if (type.writeDictKV == null)
228 |                         type.writeDictKV = FastMethod.GetMethod(GetType().TryGetMethods(nameof(WriteDictionary), new[] { type.Collection1.Type, type.Collection2.Type }, type.Type).First());
229 |                     type.writeDictKV.Invoke(this, value);
230 |                     break;
231 |                 case RuntimeCollectionType.ICollectionT:
232 |                     if (type.writeColT == null)
233 |                         type.writeColT = FastMethod.GetMethod(GetType().TryGetMethods(nameof(WriteCollection), new[] { type.Collection1.Type }, type.Type).First());
234 |                     type.writeColT.Invoke(this, value);
235 |                     break;
236 |                 case RuntimeCollectionType.IList:
237 |                     WriteList((IList)value);
238 |                     break;
239 |                 case RuntimeCollectionType.IDictionary:
240 |                     WriteDict((IDictionary)value);
241 |                     break;
242 |             }
243 |         }
244 | 
245 |         void WriteList(IList value)
246 |         {
247 |             output.Write(value.IsReadOnly);
248 |             if (value.IsReadOnly)
249 |                 return;
250 |             var count = value.Count;
251 |             output.WriteVInt(count);
252 |             for (int i = 0; i < count; i++)
253 |             {
254 |                 Write(RObject, value[i]);
255 |             }
256 |         }
257 | 
258 |         void WriteDict(IDictionary value)
259 |         {
260 |             output.Write(value.IsReadOnly);
261 |             if (value.IsReadOnly)
262 |                 return;
263 |             var count = value.Count;
264 |             output.WriteVInt(count);
265 |             foreach (DictionaryEntry kv in value)
266 |             {
267 |                 count--;
268 |                 Write(kv.Key);
269 |                 Write(kv.Value);
270 |             }
271 |             if (count != 0)
272 |                 throw new ArgumentException($"({value}.Count reported an incorrect value ({value.Count})");
273 |         }
274 | 
275 |         void WriteCollection<T>(ICollection<T> value)
276 |         {
277 |             output.Write(value.IsReadOnly);
278 |             if (value.IsReadOnly)
279 |                 return;
280 |             var count = value.Count;
281 |             output.WriteVInt(count);
282 |             var surt = RuntimeType.GetType(typeof(T));
283 |             foreach (var item in value)
284 |             {
285 |                 count--;
286 |                 Write(surt, item);
287 |             }
288 |             if (count != 0)
289 |                 throw new ArgumentException($"({value}.Count reported an incorrect value ({value.Count})");
290 |         }
291 | 
292 |         void WriteDictionary<K, V>(IDictionary<K, V> value)
293 |         {
294 |             output.Write(value.IsReadOnly);
295 |             if (value.IsReadOnly)
296 |                 return;
297 |             var count = value.Count;
298 |             output.WriteVInt(count);
299 |             var surk = RuntimeType.GetType(typeof(K));
300 |             var surv = RuntimeType.GetType(typeof(V));
301 |             foreach (var kv in value)
302 |             {
303 |                 count--;
304 |                 Write(surk, kv.Key);
305 |                 Write(surv, kv.Value);
306 |             }
307 |             if (count != 0)
308 |                 throw new ArgumentException($"({value}.Count reported an incorrect value ({value.Count})");
309 |         }
310 |     }
311 | }
312 | 


--------------------------------------------------------------------------------
/Galador.Reflection/Registry.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Collections.Generic;
  3 | using System.Linq;
  4 | using System.Text;
  5 | using System.Threading.Tasks;
  6 | using System.Reflection;
  7 | using System.Collections;
  8 | using Galador.Reflection.Utils;
  9 | 
 10 | namespace Galador.Reflection
 11 | {
 12 |     #region ExportAttribute, ImportAttribute
 13 | 
 14 |     /// <summary>
 15 |     /// Out of the box helper attribute for automatic registration with <see cref="Registry.RegisterAssemblies(Assembly[])"/>
 16 |     /// </summary>
 17 |     [AttributeUsage(AttributeTargets.Class, AllowMultiple = false)]
 18 |     public class ExportAttribute : Attribute
 19 |     {
 20 |     }
 21 | 
 22 |     /// <summary>
 23 |     /// When one resolve a type (i.e. create an instance with <see cref="Registry.Resolve(Type)"/> or <see cref="Registry.Create(Type)"/>), 
 24 |     /// all their property marked with this attribute will also be set using <see cref="Registry.Resolve(Type)"/>
 25 |     /// Can also be used on constructor parameter to specify a particular type to use.
 26 |     /// </summary>
 27 |     [AttributeUsage(AttributeTargets.Property | AttributeTargets.Parameter, AllowMultiple = false)]
 28 |     public class ImportAttribute : Attribute
 29 |     {
 30 |         /// <summary>
 31 |         /// Initializes a new instance of the <see cref="ImportAttribute"/> class.
 32 |         /// </summary>
 33 |         /// <param name="eType">(Optional) type that is imported. Will set <see cref="ImportedType"/></param>
 34 |         public ImportAttribute(Type eType = null)
 35 |         {
 36 |             ImportedType = eType;
 37 |         }
 38 |         /// <summary>
 39 |         /// The required type to be imported. If null the type of the member or constructor parameter will be used.
 40 |         /// </summary>
 41 |         public Type ImportedType { get; set; }
 42 |     }
 43 | 
 44 |     #endregion
 45 | 
 46 |     /// <summary>
 47 |     /// This class is a IServiceProvider, IOC, and MEF clone all together.
 48 |     /// Services are registered explicitly with <see cref="Register(Type, object)"/> or automatically with <see cref="RegisterAssemblies(Assembly[])"/> assembly.
 49 |     /// Then service can then be acquired / resolved, using constructor and property injection lazily with <see cref="Resolve(Type)"/>.
 50 |     /// Each registered service will be created only once. Imported object (with <see cref="ImportAttribute"/>) which are not registered as service will
 51 |     /// be created as well and cached for reuse.
 52 |     /// </summary>
 53 |     public sealed class Registry : IDisposable, IServiceProvider
 54 |     {
 55 |         readonly TypeTree<ServiceDefinition> services = new TypeTree<ServiceDefinition>();
 56 |         readonly TypeTree<object> scope = new TypeTree<object>();
 57 | 
 58 |         #region ctor() Dispose()
 59 | 
 60 |         /// <summary>
 61 |         /// Initializes a new instance of the <see cref="Registry"/> class.
 62 |         /// </summary>
 63 |         public Registry()
 64 |         {
 65 |             this.services = new TypeTree<ServiceDefinition>();
 66 |             this.scope = new TypeTree<object>();
 67 |             services[typeof(Registry)] = new ServiceDefinition(this);
 68 |         }
 69 | 
 70 |         public Registry(TypeTree<ServiceDefinition> services, TypeTree<object> scope)
 71 |         {
 72 |             this.services = services ?? new TypeTree<ServiceDefinition>();
 73 |             this.scope = scope ?? new TypeTree<object>();
 74 |             services[typeof(Registry)] = new ServiceDefinition(this);
 75 |         }
 76 | 
 77 |         /// <summary>
 78 |         /// Dispose of all <see cref="IDisposable"/> object registered with the registry and make it unusable.
 79 |         /// </summary>
 80 |         public void Dispose()
 81 |         {
 82 |             if (disposed)
 83 |                 return;
 84 |             disposed = true;
 85 |             foreach (var item in scope.GetKeyValues(typeof(object)).Select(x => x.value).OfType<IDisposable>())
 86 |                 item.Dispose();
 87 |             scope.Clear();
 88 |         }
 89 |         bool disposed;
 90 |         void EnsureAlive() { if (disposed) throw new ObjectDisposedException(GetType().Name); }
 91 | 
 92 |         /// <summary>
 93 |         /// Whether this registry has been disposed or not.
 94 |         /// </summary>
 95 |         public bool IsDisposed { get { return disposed; } }
 96 | 
 97 |         #endregion
 98 | 
 99 |         #region RegisterAssemblies()
100 | 
101 |         /// <summary>
102 |         /// Registers all typed tagged with attribute <typeparamref name="T"/> within all the known assemblies.
103 |         /// </summary>
104 |         public void RegisterAssemblies<T>()
105 |             where T: Attribute
106 |         {
107 |             RegisterAssemblies<T>(KnownAssemblies.Current);
108 |         }
109 | 
110 |         /// <summary>
111 |         /// Register some assembly, by registering all type they export that are marked with <see cref="ExportAttribute"/>.
112 |         /// </summary>
113 |         public void RegisterAssemblies<T>(params Assembly[] ass)
114 |             where T : Attribute
115 |         {
116 |             RegisterAssemblies<T>((IEnumerable<Assembly>)ass);
117 |         }
118 | 
119 |         /// <summary>
120 |         /// Register some assembly, by registering all type they export that are marked with <see cref="ExportAttribute"/>.
121 |         /// </summary>
122 |         public void RegisterAssemblies<T>(IEnumerable<Assembly> assemblies)
123 |             where T : Attribute
124 |         {
125 |             foreach (var t in assemblies.Where(x => x != null).SelectMany(x => x.GetLoadableTypes()))
126 |             {
127 |                 try
128 |                 {
129 |                     var ea = t.GetCustomAttributes<T>(false);
130 |                     foreach (var export in ea)
131 |                     {
132 |                         if (!TypeTreeActivation.CanBeInstantiated(t))
133 |                         {
134 |                             Log.Warning(this, $"[Registry]: Type {t.Name} can't be exported, it is not Resolvable.");
135 |                             continue;
136 |                         }
137 |                         Register(t);
138 |                         break; // register only once
139 |                     }
140 |                 }
141 |                 catch (TypeLoadException) { }
142 |             }
143 |         }
144 | 
145 |         #endregion
146 | 
147 |         #region Register() IsRegistered()
148 | 
149 |         /// <summary>
150 |         /// Register <typeparamref name="T"/> as an exported type. 
151 |         /// <br/><see cref="Register(Type, object)"/>.
152 |         /// </summary>
153 |         /// <typeparam name="T">The type that is registered.</typeparam>
154 |         public void Register<T>() where T : class { Register(typeof(T), null); }
155 | 
156 |         /// <summary>
157 |         /// Register <typeparamref name="T"/> as an exported type. 
158 |         /// <br/><see cref="Register(Type, object)"/>.
159 |         /// </summary>
160 |         /// <typeparam name="T">The type that is registered.</typeparam>
161 |         /// <param name="instance">The instance that is set against this type.</param>
162 |         public void Register<T>(T instance) where T : class { Register(typeof(T), instance); }
163 | 
164 |         /// <summary>
165 |         /// Register all arguments types with the registry
166 |         /// </summary>
167 |         /// <param name="types">All type to register</param>
168 |         public void Register(params Type[] types)
169 |         {
170 |             if (types == null)
171 |                 return;
172 |             foreach (var t in types)
173 |             {
174 |                 if (t == null)
175 |                     continue;
176 |                 Register(t, (object)null);
177 |             }
178 |         }
179 | 
180 |         /// <summary>
181 |         /// Register an instance as an instance of a given type. It will returned when resolving any
182 |         /// base class or implemented interface.
183 |         /// </summary>
184 |         /// <param name="facade">The type that is registered.</param>
185 |         /// <param name="instance">The instance for this type. If null it will be created on demand 
186 |         /// on the first access to <paramref name="facade"/></param>
187 |         public void Register(Type facade, object instance)
188 |         {
189 |             EnsureAlive();
190 |             TypeTreeActivation.Register(services, facade, instance);
191 |         }
192 | 
193 |         /// <summary>
194 |         /// Return whether there is an object that is registered for the requested type.
195 |         /// </summary>
196 |         /// <typeparam name="T">The type to check for registration.</typeparam>
197 |         /// <returns>Whether the given type is registered</returns>
198 |         public bool IsRegistered<T>() { return IsRegistered(typeof(T)); }
199 |         /// <summary>
200 |         /// Return whether there is an object that is registered for the requested type.
201 |         /// </summary>
202 |         /// <param name="type">The type to check for registration.</param>
203 |         /// <returns>Whether the given type is registered</returns>
204 |         public bool IsRegistered(Type type)
205 |         {
206 |             EnsureAlive();
207 |             return services.ContainsKey(type);
208 |         }
209 | 
210 |         #endregion
211 | 
212 |         public IEnumerable<ServiceDefinition> Services => services.GetKeyValues().Select(x => x.value);
213 | 
214 |         object IServiceProvider.GetService(Type serviceType) { return Resolve(serviceType); }
215 | 
216 |         /// <summary>
217 |         /// Create another registry with the same service definition, but none of the automatically created instances.
218 |         /// </summary>
219 |         public Registry CreateScope() => new Registry(services, null);
220 | 
221 |         public void ResolveProperties(object instance)
222 |         {
223 |             EnsureAlive();
224 |             TypeTreeActivation.ResolveProperties(services, scope, instance);
225 |         }
226 | 
227 |         public T Resolve<T>() => (T)Resolve(typeof(T));
228 | 
229 |         public object Resolve(Type type)
230 |         {
231 |             EnsureAlive();
232 |             return TypeTreeActivation.ResolveSingle(services, scope, type);
233 |         }
234 | 
235 |         public IEnumerable<T> ResolveAll<T>() => ResolveAll(typeof(T)).OfType<T>(); 
236 | 
237 |         public IEnumerable<object> ResolveAll(Type type)
238 |         {
239 |             EnsureAlive();
240 |             return TypeTreeActivation.Resolve(services, scope, type);
241 |         }
242 | 
243 |         public IEnumerable<object> ResolveAll(Predicate<Type> matching)
244 |         {
245 |             EnsureAlive();
246 |             return TypeTreeActivation.Resolve(services, scope, matching);
247 |         }
248 | 
249 | 
250 |         /// <summary>
251 |         /// Whether given type can be created. Basically it must be a concrete class with some constructors
252 |         /// with arguments that can also be created (or resolved).
253 |         /// </summary>
254 |         /// <typeparam name="T">The type to check for creation.</typeparam>
255 |         /// <returns>Whether the type can be instantiated</returns>
256 |         public bool CanCreate<T>() { return CanCreate(typeof(T)); }
257 | 
258 |         /// <summary>
259 |         /// Whether given type can be created. Basically it must be a concrete class with some constructors
260 |         /// with arguments that can also be created (or resolved).
261 |         /// </summary>
262 |         /// <param name="type">The type to check for creation.</param>
263 |         /// <returns>Whether the type can be instantiated</returns>
264 |         public bool CanCreate(Type type)
265 |         {
266 |             EnsureAlive();
267 |             return TypeTreeActivation.CanCreate(services, scope, type);
268 |         }
269 | 
270 |         /// <summary>
271 |         /// Create that object from scratch regardless of registration
272 |         /// </summary>
273 |         /// <typeparam name="T">The type to instantiate.</typeparam>
274 |         /// <returns>A newly created instance</returns>
275 |         /// <exception cref="InvalidOperationException">If no appropriate constructor can be found.</exception>
276 |         public T Create<T>() { return (T)Create(typeof(T)); }
277 | 
278 |         public T Create<T>(params object[] parameters) { return (T)Create(typeof(T), null, parameters); }
279 | 
280 |         /// <summary>
281 |         /// Create that object from scratch regardless of registration
282 |         /// </summary>
283 |         /// <param name="type">The type to instantiate.</param>
284 |         /// <returns>A newly created instance</returns>
285 |         /// <exception cref="InvalidOperationException">If no appropriate constructor can be found.</exception>
286 |         public object Create(Type type, params object[] parameters)
287 |         {
288 |             EnsureAlive();
289 |             return TypeTreeActivation.Create(services, scope, type, parameters);
290 |         }
291 |     }
292 | }
293 | 


--------------------------------------------------------------------------------
/Galador.Reflection/Utils/TypeDescription.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Collections.Generic;
  3 | using System.Text;
  4 | using System.Linq;
  5 | using System.Reflection;
  6 | using System.ComponentModel;
  7 | using System.Globalization;
  8 | using Galador.Reflection.Utils;
  9 | 
 10 | namespace Galador.Reflection.Utils
 11 | {
 12 |     /// <summary>
 13 |     /// <see cref="TypeConverter"/> for <see cref="TypeDescription"/>
 14 |     /// </summary>
 15 |     public class TypeDescriptionConverter : System.ComponentModel.TypeConverter
 16 |     {
 17 |         /// <summary>
 18 |         /// Determines whether this instance [can convert from] the specified context.
 19 |         /// </summary>
 20 |         /// <param name="context">The context.</param>
 21 |         /// <param name="sourceType">Type of the source.</param>
 22 |         public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
 23 |         {
 24 |             return sourceType == typeof(string);
 25 |         }
 26 |         /// <summary>
 27 |         /// Determines whether this instance [can convert to] the specified context.
 28 |         /// </summary>
 29 |         /// <param name="context">The context.</param>
 30 |         /// <param name="destinationType">Type of the destination.</param>
 31 |         /// <returns></returns>
 32 |         public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
 33 |         {
 34 |             return destinationType == typeof(string);
 35 |         }
 36 |         /// <summary>
 37 |         /// Converts from.
 38 |         /// </summary>
 39 |         /// <param name="context">The context.</param>
 40 |         /// <param name="culture">The culture.</param>
 41 |         /// <param name="value">The value.</param>
 42 |         /// <returns></returns>
 43 |         public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
 44 |         {
 45 |             var s = (string)value;
 46 |             return new TypeDescription(s);
 47 |         }
 48 |         /// <summary>
 49 |         /// Converts to.
 50 |         /// </summary>
 51 |         /// <param name="context">The context.</param>
 52 |         /// <param name="culture">The culture.</param>
 53 |         /// <param name="value">The value.</param>
 54 |         /// <param name="destinationType">Type of the destination.</param>
 55 |         /// <returns></returns>
 56 |         public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
 57 |         {
 58 |             var ts = (TypeDescription)value;
 59 |             return ts.ToString();
 60 |         }
 61 |     }
 62 | 
 63 |     /// <summary>
 64 |     /// This class help transform type to string description and vice version. 
 65 |     /// The string format is very similar to standard .NET type string, except the assembly name is just the name, without version of hash.
 66 |     /// </summary>
 67 |     /// <remarks>This class is a left over of previous iteration and not use anywhere by the serializer currently</remarks>
 68 |     [System.ComponentModel.TypeConverter(typeof(TypeDescriptionConverter))]
 69 |     public sealed class TypeDescription
 70 |     {
 71 |         /// <summary>
 72 |         /// FullName of the represented type.
 73 |         /// </summary>
 74 |         public string Fullname { get; private set; }
 75 |         /// <summary>
 76 |         /// Assembly name for the assembly declaring that type.
 77 |         /// </summary>
 78 |         public string AssemblyName { get; private set; }
 79 |         /// <summary>
 80 |         /// How many 'stars' for pointer type.
 81 |         /// </summary>
 82 |         public byte PointerCount { get; private set; }
 83 | 
 84 |         /// <summary>
 85 |         /// Type argument for generic type.
 86 |         /// </summary>
 87 |         public IReadOnlyList<TypeDescription> TypeArguments { get { return mTypeArguments; } }
 88 |         List<TypeDescription> mTypeArguments = new List<TypeDescription>();
 89 | 
 90 |         /// <summary>
 91 |         /// Array ranks for array type.
 92 |         /// </summary>
 93 |         public IReadOnlyList<byte> ArrayRanks { get { return mArrayRanks; } }
 94 |         List<byte> mArrayRanks = new List<byte>();
 95 | 
 96 | 
 97 |         /// <summary>
 98 |         /// Compare this to another <see cref="TypeDescription"/>
 99 |         /// </summary>
100 |         /// <returns>Whether <param name="obj"/> is a <see cref="TypeDescription"/> of the same type, or not.</returns>
101 |         public override bool Equals(object obj)
102 |         {
103 |             var o = obj as TypeDescription;
104 |             if (o == null
105 |                 || o.Fullname != Fullname
106 |                 || o.AssemblyName != AssemblyName)
107 |                 return false;
108 |             if (o.TypeArguments.Count != TypeArguments.Count)
109 |                 return false;
110 |             for (int i = 0; i < TypeArguments.Count; i++)
111 |                 if (!TypeArguments[i].Equals(o.TypeArguments[i]))
112 |                     return false;
113 |             if (o.ArrayRanks.Count != ArrayRanks.Count)
114 |                 return false;
115 |             for (int i = 0; i < ArrayRanks.Count; i++)
116 |                 if (ArrayRanks[i] != o.ArrayRanks[i])
117 |                     return false;
118 |             return true;
119 |         }
120 |         /// <summary>
121 |         /// Returns a hash code for this instance.
122 |         /// </summary>
123 |         /// <returns>
124 |         /// A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table. 
125 |         /// </returns>
126 |         public override int GetHashCode()
127 |         {
128 |             int val = Fullname.GetHashCode();
129 |             if (AssemblyName != null)
130 |                 val ^= AssemblyName.GetHashCode();
131 |             foreach (var item in TypeArguments)
132 |                 val ^= item.GetHashCode();
133 |             val ^= ArrayRanks.Select(x => (int)x).Sum();
134 |             return base.GetHashCode();
135 |         }
136 | 
137 |         /// <summary>
138 |         /// Create a <see cref="TypeDescription"/> for <param name="type"></param>
139 |         /// </summary>
140 |         public TypeDescription(Type type)
141 |         {
142 |             while (type.IsArray)
143 |             {
144 |                 var rank = type.GetArrayRank();
145 |                 mArrayRanks.Insert(0, (byte)rank);
146 |                 type = type.GetElementType();
147 |             }
148 |             while (type.IsPointer)
149 |             {
150 |                 PointerCount++;
151 |                 type = type.GetElementType();
152 |             }
153 |             if (type.GetTypeInfo().IsGenericType && !type.GetTypeInfo().IsGenericTypeDefinition)
154 |             {
155 |                 foreach (var arg in type.GetTypeInfo().GetGenericArguments())
156 |                 {
157 |                     var sub = new TypeDescription(arg);
158 |                     mTypeArguments.Add(sub);
159 |                 }
160 |                 type = type.GetGenericTypeDefinition();
161 |             }
162 |             Fullname = type.FullName;
163 |             var ass = type.GetTypeInfo().Assembly;
164 |             if (ass != FastType.MSCORLIB)
165 |             {
166 |                 AssemblyName = ass.GetName().Name;
167 |             }
168 |         }
169 | 
170 |         /// <summary>
171 |         /// Parse a string as a TypeDescription
172 |         /// </summary>
173 |         /// <param name="s"></param>
174 |         public TypeDescription(string s) { Parse(s, 0); }
175 | 
176 |         TypeDescription() { }
177 |         int Parse(string s, int index)
178 |         {
179 |             Func<int, int> next = (start) =>
180 |             {
181 |                 for (int i = start; i < s.Length; i++)
182 |                 {
183 |                     var c = s[i];
184 |                     if (c == ',' || c == '[' || c == ']' || c == '*')
185 |                         return i;
186 |                 }
187 |                 return s.Length;
188 |             };
189 | 
190 |             var i2 = next(index);
191 |             Fullname = s.Substring(index, i2 - index).Trim();
192 |             if (i2 >= s.Length || s[i2] == ']')
193 |                 return i2;
194 |             if (s[i2] == ',')
195 |                 goto labelAssembly;
196 |             if (s[i2] == '*')
197 |                 goto labelPointer;
198 |             var i3 = next(i2 + 1);
199 |             if (s[i3] == ',' || s[i3] == ']')
200 |                 goto labelArray;
201 |             if (i2 < s.Length && s[i2] == '[')
202 |             {
203 |                 i2 = i3;
204 |                 while (i2 < s.Length && s[i2] != ']')
205 |                 {
206 |                     if (s[i2] == ',')
207 |                         i2 = next(i2 + 1);
208 |                     if (i2 >= s.Length || s[i2] != '[')
209 |                         return i2;
210 |                     var sub = new TypeDescription();
211 |                     mTypeArguments.Add(sub);
212 |                     i2 = sub.Parse(s, i2 + 1);
213 |                     if (i2 >= s.Length || s[i2] != ']')
214 |                         return i2;
215 |                     i2 = next(i2 + 1);
216 |                 }
217 |                 i2 = next(i2 + 1);
218 |             }
219 |             labelPointer:
220 |             while (i2 < s.Length && s[i2] == '*')
221 |             {
222 |                 PointerCount++;
223 |                 i2++;
224 |             }
225 |             labelArray:
226 |             if (i2 < s.Length && s[i2] == '[')
227 |             {
228 |                 byte rank = 1;
229 |                 do
230 |                 {
231 |                     i2 = next(i2 + 1);
232 |                     if (i2 < s.Length && s[i2] == ',')
233 |                         checked { rank++; };
234 |                 }
235 |                 while (i2 < s.Length && s[i2] != ']');
236 |                 mArrayRanks.Add(rank);
237 |                 i2++;
238 |                 if (i2 < s.Length && s[i2] == '[')
239 |                     goto labelArray;
240 |             }
241 |             labelAssembly:
242 |             if (i2 < s.Length && s[i2] == ',')
243 |             {
244 |                 i3 = next(i2 + 1);
245 |                 AssemblyName = s.Substring(i2 + 1, i3 - i2 - 1).Trim();
246 |                 i2 = i3;
247 |             }
248 |             return i2;
249 |         }
250 | 
251 |         /// <summary>
252 |         /// Attempt to create the type that corresponds to that description.
253 |         /// </summary>
254 |         public Type Resolve()
255 |         {
256 |             var type = KnownAssemblies.GetType(Fullname, AssemblyName);
257 |             if (type == null)
258 |                 return null;
259 |             if (TypeArguments.Count > 0)
260 |             {
261 |                 if (!type.GetTypeInfo().IsGenericTypeDefinition || type.GetTypeInfo().GetGenericArguments().Length != TypeArguments.Count)
262 |                     return null;
263 |                 var args = TypeArguments.Select(x => x.Resolve()).ToArray();
264 |                 if (args.Any(x => x == null))
265 |                     return null;
266 |                 type = type.MakeGenericType(args);
267 |             }
268 |             if (PointerCount > 0)
269 |             {
270 |                 int pc = PointerCount;
271 |                 while (pc-- > 0)
272 |                     type = type.MakePointerType();
273 |             }
274 |             foreach (var rank in ArrayRanks)
275 |             {
276 |                 if (rank == 1) type = type.MakeArrayType();
277 |                 else type = type.MakeArrayType(rank);
278 |             }
279 |             return type;
280 |         }
281 |         /// <summary>
282 |         /// Returns a <see cref="System.String" /> that represents this instance.
283 |         /// </summary>
284 |         /// <returns>
285 |         /// A <see cref="System.String" /> that represents this instance.
286 |         /// </returns>
287 |         public override string ToString()
288 |         {
289 |             var sb = new StringBuilder();
290 |             ToString(sb);
291 |             return sb.ToString();
292 |         }
293 |         void ToString(StringBuilder sb)
294 |         {
295 |             sb.Append(Fullname);
296 |             if (TypeArguments.Count > 0)
297 |             {
298 |                 sb.Append('[');
299 |                 for (int i = 0; i < TypeArguments.Count; i++)
300 |                 {
301 |                     var arg = TypeArguments[i];
302 |                     if (i > 0)
303 |                         sb.Append(',');
304 |                     sb.Append('[');
305 |                     arg.ToString(sb);
306 |                     sb.Append(']');
307 | 
308 |                 }
309 |                 sb.Append(']');
310 |             }
311 |             if (PointerCount > 0)
312 |                 sb.Append('*', PointerCount);
313 |             foreach (var rank in ArrayRanks)
314 |             {
315 |                 sb.Append('[');
316 |                 for (int i = 0; i < rank - 1; i++)
317 |                     sb.Append(',');
318 |                 sb.Append(']');
319 |             }
320 |             if (AssemblyName != null)
321 |                 sb.Append(",").Append(AssemblyName);
322 |         }
323 |     }
324 | }
325 | 


--------------------------------------------------------------------------------