private void GuessType(object param, IEnumerable vals, object type)
{
if (param == null)
{
throw new ArgumentNullException("param", "Type can not be guessed for a null value."); // Use 'nameof' expression
}
if (type == null)
{
throw new ArgumentNullException(string.Format("Empty type '{0}'", type.GetType())); // Use string interpolation + possible NRE
}
if (vals == null)
{
throw new ArgumentNullException("vals"); // Use 'nameof' expression
}
if (!(param.ToString() == "check")) // Simplify negative equality expression
{
}
if (type == typeof(int)) // Possible unintended reference comparison
{
// Source: http://stackoverflow.com/questions/9234009/c-sharp-type-comparison-type-equals-vs-operator
Type type = new TypeDelegator(typeof(int)); // Merge variables
Console.WriteLine(type.Equals(typeof(int))); // Check for reference equality instead
}
bool serializable = (type != null && type is Abstraction); // Merge sequential checks
}
static void Main(string[] args)
{
Console.OutputEncoding = Encoding.UTF8;
List <Worker> list = new List <Worker>();
list.Add(new Worker(0, "Dima", "Home"));
list.Add(new Worker(20, "Dima2", "Home2"));
list.Add(new Worker(330, "Dima3", "Home3"));
SaveAsXmlFormat(list, "data.xml");
LoadFromXmlFormat(ref list, "data.xml");
foreach (Worker i in list)
{
Console.WriteLine($"Имя: {i.FirstName}, Организация: {i.Organization}, Место работы: {i.Organization}");
}
//worker.WorkededHandler += (sender, s) =>
//{
// Console.WriteLine("Работа была завершена и на данный момент на счету: " + s.Sum + "\u20BD");
// Console.WriteLine($"Спасибо за работу {s.FirstName} в нашей организации:'{s.Organization}'");
//};
//worker.Worked(worker);
//worker.DoubleWorked(worker);
//SaveAsXMLFormat(worker, "data.xml");
//Worker newWorker = LoadFromXMLFormat("data.xml");
//Console.WriteLine($"{newWorker.FirstName} {newWorker.Organization} {newWorker.Sum}");
Console.ReadKey();
Type type = new TypeDelegator(typeof(Worker));
Console.ReadKey();
}
public void DeclaringTypeMustReturnNonInflatedType()
{
var ut = new TypeDelegator(typeof(int));
var ut2 = typeof(Bar <> .Foo <>);
var t = ut2.MakeGenericType(ut, ut);
Assert.AreSame(typeof(Bar <>), t.DeclaringType, "#1");
}
public void GenerateVoidMapTest()
{
Type Void = new TypeDelegator(typeof(VoidCase));
Map map = new Map();
// foreach (var mapCase in map.MapContent)
// {
// Assert.AreEqual(typeof(VoidCase) , mapCase.GetType());
// }
}
public void IsAssignableFrom()
{
TypeDelegator td = new TypeDelegator(typeof(int));
Assert.AreEqual(true, typeof(int).IsAssignableFrom(td));
Assert.AreEqual(false, typeof(string).IsAssignableFrom(td));
Assert.AreEqual(true, td.IsAssignableFrom(typeof(int)));
Assert.AreEqual(false, td.IsAssignableFrom(typeof(string)));
}
public void IsAssignableTo()
{
TypeDelegator td = new TypeDelegator(typeof(int));
Assert.True(td.IsAssignableTo(typeof(int)));
Assert.False(td.IsAssignableTo(typeof(string)));
Assert.True(typeof(int).IsAssignableTo(td));
Assert.False(typeof(string).IsAssignableTo(td));
}
public void IsAssignableFrom()
{
TypeDelegator td = new TypeDelegator(typeof(int));
Assert.True(typeof(int).IsAssignableFrom(td));
Assert.False(typeof(string).IsAssignableFrom(td));
Assert.True(td.IsAssignableFrom(typeof(int)));
Assert.False(td.IsAssignableFrom(typeof(string)));
}
private static object InstantiateType(Type type)
{
try {
ProtoBuf.Item item = new ProtoBuf.Item();
var element = Activator.CreateInstance(type);
IntPtr baseAddress = TypeDelegator.GetTypeHandle(element).Value;
var fields = type.GetFields(BindingFlags.Public | BindingFlags.Instance);
foreach (var field in fields)
{
if (field.FieldType.IsEquivalentTo(typeof(String)))
{
field.SetValue(element, "RI");
}
else if (field.FieldType.IsEquivalentTo(typeof(Byte[])))
{
field.SetValue(element, new byte[0]);
}
else if (typeof(IList).IsAssignableFrom(field.FieldType))
{
var itemType = field.FieldType.GetGenericArguments()[0];
object listItem = null;
if (itemType.IsEquivalentTo(typeof(ProtoBuf.PlayerNameID)))
{
listItem = InstantiateType(typeof(ProtoBuf.PlayerNameID));
}
else if (itemType.IsEquivalentTo(typeof(ProtoBuf.RespawnInformation.SpawnOptions)))
{
listItem = InstantiateType(typeof(ProtoBuf.RespawnInformation.SpawnOptions));
}
else if (itemType.IsEquivalentTo(typeof(ProtoBuf.ClientReady.ClientInfo)))
{
listItem = InstantiateType(typeof(ProtoBuf.ClientReady.ClientInfo));
}
else
{
listItem = Activator.CreateInstance(itemType);
}
var list = Activator.CreateInstance(field.FieldType);
field.FieldType.GetMethod("Add").Invoke(list, new[] { listItem });
field.SetValue(element, list);
}
else if (typeof(IProto).IsAssignableFrom(field.FieldType))
{
field.SetValue(element, InstantiateType(field.FieldType));
}
else
{
field.SetValue(element, Activator.CreateInstance(field.FieldType));
}
}
return(element);
} catch (Exception ex) {
Console.WriteLine(ex);
}
return(null);
}
public void BaseTypeMustReturnNonInflatedType()
{
var ut = new TypeDelegator(typeof(int));
var ut2 = typeof(SubClass <>);
var t = ut2.MakeGenericType(ut);
//This is Base<K> where K is SubClass::K
var expected = typeof(Base <>).MakeGenericType(typeof(SubClass <>).GetGenericArguments()[0]);
Assert.AreSame(expected, t.BaseType, "#1");
}
public async Task CanGetUsuarioById()
{
var httpResponse = await _client.GetAsync("/api/Usuarios/1");
httpResponse.EnsureSuccessStatusCode();
var stringResponse = await httpResponse.Content.ReadAsStringAsync();
var User = JsonConvert.DeserializeObject <Usuario>(stringResponse);
Type type = new TypeDelegator(typeof(Usuario));
Assert.False(User.GetType() == type);
}
public void GetAttributesNullTest()
{
var provider = new DataAnnotationsModelMetadataProvider();
var modelType = new TypeDelegator(typeof(TestModel));
var t = new ModelMetadata(provider, null, null, modelType, string.Empty);
t.AdditionalValues["Attributes"] = new List <DisplayAttribute>();
var a = t.GetAttributes <DisplayAttribute>();
Assert.IsNotNull(a);
Assert.AreEqual(0, a.Count());
}
public void BeforeAllTests()
{
_balloonProgramTypeInfo = new TypeDelegator(typeof(BalloonProgram));
var assembly = Assembly.GetAssembly(typeof(Program));
_writeDelegateTypeInfo = assembly.DefinedTypes.FirstOrDefault(t =>
{
if (!typeof(MulticastDelegate).IsAssignableFrom(t))
{
return(false);
}
//check signature (must return void and have a string parameter)
var methodInfo = t.DeclaredMethods.First(p => p.Name == "Invoke");
if (methodInfo.ReturnType.Name.ToLower() != "void")
{
return(false);
}
ParameterInfo[] parameters = methodInfo.GetParameters();
if (parameters.Length != 1)
{
return(false);
}
if (parameters[0].ParameterType != typeof(string))
{
return(false);
}
return(true);
});
if (_writeDelegateTypeInfo != null)
{
_constructorTypeInfo = _balloonProgramTypeInfo.GetConstructors().FirstOrDefault(c =>
{
var parameters = c.GetParameters();
if (parameters.Length != 1)
{
return(false);
}
return(parameters[0].ParameterType == _writeDelegateTypeInfo.AsType());
});
if (_constructorTypeInfo != null)
{
MethodInfo handlerMethodInfo = typeof(BalloonProgramTests).GetMethod(nameof(LogWrite), BindingFlags.NonPublic | BindingFlags.Instance);
Delegate writeDelegate = Delegate.CreateDelegate(_writeDelegateTypeInfo, this, handlerMethodInfo);
_program = (BalloonProgram)_constructorTypeInfo.Invoke(new object[] { writeDelegate });
}
}
_balloonProgramClassContent = Solution.Current.GetFileContent(@"Exercise1\BalloonProgram.cs");
}
public Form1()
{
InitializeComponent();
type = TypeDelegator.GetTypeFromProgID("MSCAL.Календарь.7");
calendar = Activator.CreateInstance(type);
day = (short)type.InvokeMember("Day", BindingFlags.GetProperty, null, calendar, null);
month = (short)type.InvokeMember("Month", BindingFlags.GetProperty, null, calendar, null);
year = (short)type.InvokeMember("Year", BindingFlags.GetProperty, null, calendar, null);
day_txt.Text = day.ToString();
month_txt.Text = month.ToString();
}
public dynamic LoadVm(string typeStr)
{
dynamic dyn = new System.Dynamic.ExpandoObject();
var type = Type.GetType(typeStr);
if (type != null)
{
var vm = Activator.CreateInstance(type);
TypeInfo typeInfo = new TypeDelegator(type);
var method = typeInfo.GetMethod("Add");
method?.Invoke(vm, new object[] { null });
dyn.VM = vm;
}
return(dyn);
}
// searches for the class, initiates it (calls factory method) and returns the instance
// TODO: add a lot of error handling!
ICalculate CreateCachableICalculate(string className)
{
if (!InstanceCreateCache.ContainsKey(className))
{
// get the type (several ways exist, this is an eays one)
Type type = TypeDelegator.GetType("AirportListTest." + className);
// NOTE: do NOT use the following, because you cannot create a delegate from a ctor!
ConstructorInfo constructorInfo = type.GetConstructor(Type.EmptyTypes);
// works with public instance/static methods
MethodInfo mi = type.GetMethod("Create");
// the "magic", turn it into a delegate
var createInstanceDelegate = (Func <ICalculate>)Delegate.CreateDelegate(typeof(Func <ICalculate>), mi);
// store for future reference
InstanceCreateCache.Add(className, createInstanceDelegate);
}
return(InstanceCreateCache[className].Invoke());
}
public static T ConvertToObject(DataRow dr, string prefix = "")
{
T t = new T();
PropertyInfo[] targetProperties = typeof(T).GetProperties();
DataColumnCollection columns = dr.Table.Columns;
foreach (PropertyInfo i in targetProperties)
{
var aa = i.PropertyType;
Console.WriteLine(aa);
string name = prefix + i.Name;
if (columns.Contains(name))
{
object value = dr[name];
if (value != DBNull.Value)
{
if (i.PropertyType == typeof(bool))
{
i.SetValue(t, (true.Equals(value) || "1".Equals(value) || "Y".Equals(value)), null);
}
else if (i.PropertyType.IsEnum)
{
i.SetValue(t, Enum.ToObject(i.PropertyType, value));
}
else
{
if (i.PropertyType.ToString().Contains("System.Nullable"))
{
string propertyType = i.PropertyType.ToString().Substring(i.PropertyType.ToString().IndexOf('[') + 1);
propertyType = propertyType.Remove(propertyType.LastIndexOf(']'));
i.SetValue(t, Convert.ChangeType(value, TypeDelegator.GetType(propertyType)), null);
}
else
{
i.SetValue(t, Convert.ChangeType(value, i.PropertyType), null);
}
}
}
}
}
return(t);
}
public void GetAttribute_PredicateTest()
{
var provider = new DataAnnotationsModelMetadataProvider();
var modelType = new TypeDelegator(typeof(TestModel));
var t = new ModelMetadata(provider, null, null, modelType, string.Empty);
t.AdditionalValues["Attributes"] = new List <DisplayAttribute>()
{
new DisplayAttribute()
{
Name = "TestField", Order = 1
}
};
var a = t.GetAttribute <DisplayAttribute>(p => p.Name.Equals("TestField"));
Assert.IsNotNull(a);
Assert.AreEqual("TestField", a.Name);
Assert.AreEqual(1, a.Order);
}
/// <summary>
/// Allows the sprite to handle user input.
/// </summary>
/// <param name="input">The input.</param>
public void OnEnter(Player player)
{
// Play the sound and deactivate the door
this._doorSound.Play();
this._isActive = false;
CollisionManager.Collection.QueuePendingRemoval(this);
// Create the level
var screenType = TypeDelegator.GetType("SoftProGameWindows." + this._levelScreenName);
var screen = (LevelScreen)Activator.CreateInstance(screenType);
// Add it to the screen manager
var sm = this.GetService <ScreenManager>();
sm.AddScreen(screen, null);
// Spawn the player
screen.SpawnPlayer(player);
}
public async Task CanPostUsuario()
{
var formContent = new FormUrlEncodedContent(new[]
{
new KeyValuePair <string, string>("nombre", "dominic"),
new KeyValuePair <string, string>("apellido", "di´cococ"),
new KeyValuePair <string, string>("email", "*****@*****.**"),
new KeyValuePair <string, string>("password", "8D969EEF6ECAD3C29A3A629280E686CF0C3F5D5A86AFF3CA12020C923ADC6C92"),
});
var httpResponse = await _client.PostAsync("/api/Usuarios/", formContent);
httpResponse.EnsureSuccessStatusCode();
var stringResponse = await httpResponse.Content.ReadAsStringAsync();
var User = JsonConvert.DeserializeObject <Usuario>(stringResponse);
Type type = new TypeDelegator(typeof(Usuario));
Assert.False(User.GetType() == type);
}
public T To <T>(object param)
{
var out_type = new TypeDelegator(typeof(T));
if (out_type.Equals(typeof(int)))
{
return((T)(int.Parse(param.ToString()) as object));
}
if (out_type.Equals(typeof(long)))
{
return((T)(long.Parse(param.ToString()) as object));
}
if (out_type.Equals(typeof(double)))
{
return((T)(double.Parse(param.ToString()) as object));
}
if (out_type.Equals(typeof(decimal)))
{
return((T)(decimal.Parse(param.ToString()) as object));
}
if (out_type.Equals(typeof(float)))
{
return((T)(float.Parse(param.ToString()) as object));
}
if (out_type.Equals(typeof(Version)))
{
return((T)(Version.Parse(param.ToString()) as object));
}
if (out_type.Equals(typeof(DateTime)))
{
return((T)(DateTime.Parse(param.ToString()) as object));
}
if (out_type.Equals(typeof(string)))
{
return((T)(param as object));
}
else
{
return((T)param);
}
}
private void KillUsers()
{
#if !NO1CCOM
Type type = TypeDelegator.GetTypeFromProgID("V83.ComConnector");
dynamic V8 = Activator.CreateInstance(type);
dynamic Agent = V8.ConnectAgent(MainSettings.LocalSqlSettings.Server1C); // Соединились с 1С Агентом
dynamic Clusters = Agent.GetClusters();
int ClustersCount = Clusters.GetLength(0);
for (int i = 0; i < ClustersCount; i++)
{
dynamic CurrentCluster = Clusters[i];
Agent.Authenticate(CurrentCluster, "", "");
dynamic IBSessions = Agent.GetSessions(CurrentCluster);
int SessionsCount = IBSessions.GetLength(0);
for (int k = 0; k < SessionsCount; k++)
{
Agent.TerminateSession(CurrentCluster, IBSessions[k]);
}
}
#endif
}
public async Task CanPostUser()
{
var user = new User()
{
nombre = "Antonio",
apellido = "Margarete",
email = "*****@*****.**",
password = "******"
};
var result = JsonConvert.SerializeObject(user);
var content = new StringContent(result.ToString(), Encoding.UTF8, "application/json");
var httpResponse = await _client.PostAsync("/api/Users/", content);
httpResponse.EnsureSuccessStatusCode();
var stringResponse = await httpResponse.Content.ReadAsStringAsync();
var User = JsonConvert.DeserializeObject <User>(stringResponse);
Type type = new TypeDelegator(typeof(User));
Assert.False(User.GetType() == type);
}
protected override void ActExecution()
{
#if !NO1CCOM
Type type = TypeDelegator.GetTypeFromProgID("V83.ComConnector");
dynamic V8 = Activator.CreateInstance(type);
dynamic Agent = V8.ConnectAgent(MainSettings.LocalSqlSettings.Server1C); // Соединились с 1С Агентом
dynamic Clusters = Agent.GetClusters();
int ClustersCount = Clusters.GetLength(0);
for (int i = 0; i < ClustersCount; i++)
{
dynamic CurrentCluster = Clusters[i];
Agent.Authenticate(CurrentCluster, "", "");
dynamic WorkingProcess = Agent.GetWorkingProcesses(CurrentCluster);
dynamic currentwp = WorkingProcess[0];
String Port = (String)currentwp.MainPort.ToString();
String HostName = (String)currentwp.HostName;
String ConnStr = HostName + ":" + Port;
dynamic wpConnection = V8.ConnectWorkingProcess(ConnStr);
wpConnection.AddAuthentication(MainSettings.LocalSqlSettings.User1C, MainSettings.LocalSqlSettings.Pass1C);
dynamic IBArray = wpConnection.GetInfoBases();
int Count = IBArray.GetLength(0);
for (int j = 0; j < Count; j++)
{
dynamic currentIB = IBArray[j];
if (string.Compare(currentIB.Name, MainSettings.LocalSqlSettings.Base1C, true) == 0)
{
currentIB.ScheduledJobsDenied = false;
wpConnection.UpdateInfoBase(currentIB);
}
}
}
#endif
}
public static List <IBeingInterface> AddBeing(byte[] dll)
{
List <IBeingInterface> objects = new List <IBeingInterface>();
Assembly assembly = Assembly.Load(dll);
string iMyInterfaceName = typeof(IBeingInterface).ToString();
TypeDelegator[] defaultConstructorParametersTypes = new TypeDelegator[0];
object[] defaultConstructorParameters = new object[0];
IBeingInterface iAI = null;
foreach (Type type in assembly.GetTypes())
{
if (type.GetInterface(iMyInterfaceName) != null)
{
ConstructorInfo defaultConstructor = type.GetConstructor(defaultConstructorParametersTypes);
object instance = defaultConstructor.Invoke(defaultConstructorParameters);
iAI = (IBeingInterface)instance; //Достаём таки нужный интерфейс
//
objects.Add(iAI);
}
}
return(objects);
}
public static T ConvertToObject(object obj)
{
T t = new T();
PropertyInfo[] targetProperties = typeof(T).GetProperties();
PropertyInfo[] sourceProperties = obj.GetType().GetProperties();
foreach (PropertyInfo i in targetProperties)
{
var sp = (from p in sourceProperties
where p.Name == i.Name
select p).FirstOrDefault();
if (null == sp)
{
continue; // property not found
}
if (i.PropertyType.Equals(sp.PropertyType))
{
i.SetValue(t, sp.GetValue(obj), null);
}
else if (i.PropertyType.ToString().Contains("System.Nullable"))
{
// 取得原始變數類型
string propertyType = i.PropertyType.ToString().Substring(i.PropertyType.ToString().IndexOf('[') + 1);
propertyType = propertyType.Remove(propertyType.LastIndexOf(']'));
i.SetValue(t, Convert.ChangeType(sp.GetValue(obj), TypeDelegator.GetType(propertyType)), null);
}
else
{
i.SetValue(t, Convert.ChangeType(sp.GetValue(obj), i.PropertyType), null);
}
}
return(t);
}
public ExternalType(Type type)
{
delegator = new TypeDelegator(type);
}
