private void btnInBieu_Click(object sender, EventArgs e)
{
try
{
//Convert to datatable for export to excel
DataTable dataList = ConverterMethod.ConvertDataGridViewToDataTable(dataGridHDLD);
if (dataList.Rows.Count != 0)
{
ExportToExcel(dataList);
}
else
{
MessageBox.Show("Không Có Thông Tin Để Trích Xuất", "Thông Báo!", MessageBoxButtons.OK);
}
}
catch (Exception ex)
{
if (UserProfile.permission == 1)
{
MessageBox.Show(ex.ToString(), "Error!", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
else
{
MessageBox.Show("Trích Xuất Excel Không Thành Công!", "Error!", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
}
public StringObjectSerial(XmlNode _node)
{
XmlNamedNodeMap map_ = _node.Attributes;
String name_ = _node.Name;
XmlNode className_ = map_.GetNamedItem(CLASS);
if (className_ != null)
{
setClassName(className_.Value);
}
XmlNode field_ = map_.GetNamedItem(FIELD);
if (field_ != null)
{
setField(field_.Value);
}
XmlNode keyOfMap_ = map_.GetNamedItem(KEY);
if (keyOfMap_ != null)
{
setKeyOfMap(true);
}
//try {
Type class_ = Constants.classForName(_node.Name);
XmlNode value_ = map_.GetNamedItem(VALUE);
if (value_ == null)
{
//throw new NoValueException(name_);
throw new NoValueException();
}
MethodInfo method_ = ConverterMethod.getFromStringMethod(class_);
if (method_ != null)
{
value = method_.Invoke(null, new object[] { value_.Value });
return;
}
if (!typeof(Primitivable).IsAssignableFrom(class_))
{
//throw an exception
throw new ClassFoundException();
}
//Class<? extends Primitivable> subClass_ = class_.asSubclass(Primitivable.class);
ConstructorInfo constr_ = class_.GetConstructor(new Type[] { typeof(string) });
//constr_.setAccessible(constr_.getAnnotation(RwXml.class)!=null);
// constr_.setAccessible(true);
value = constr_.Invoke(new object[] { value_.Value });
/*} catch (IllegalArgumentException e) {
* } catch (IllegalAccessException e) {
* e.printStackTrace();*/
//}
}
public override XmlElement serializeWithoutRef(XmlDocument _doc)
{
XmlElement node_ = base.serializeMetaInfo(_doc);
MethodInfo method_ = ConverterMethod.getToStringMethod(getValueClass());
if (method_ != null)
{
node_.SetAttribute(VALUE, method_.Invoke(getValue(), new object[] { }).ToString());
}
else
{
node_.SetAttribute(VALUE, getValue().ToString());
}
return(node_);
}
/// <summary>
/// Retrieves an array from a byte array using the supplied converter
/// to read each individual element from the supplied byte array
/// </summary>
/// <param name="data"></param>
/// <param name="elementLengthBytes"></param>
/// <param name="converter"></param>
/// <returns></returns>
private static Array GetArray <T>(byte[] data, int elementLengthBytes, ConverterMethod <T> converter)
{
Array convertedData = new T[data.Length / elementLengthBytes];
var buffer = new byte[elementLengthBytes];
// Read each element from the array
for (int elementCount = 0; elementCount < data.Length / elementLengthBytes; elementCount++)
{
// Place the data for the current element into the buffer
Array.Copy(data, elementCount * elementLengthBytes, buffer, 0, elementLengthBytes);
// Process the data and place it into the output array
convertedData.SetValue(converter(buffer), elementCount);
}
return(convertedData);
}
private static TDataType[] ToArray <TDataType>(ExifDataType dataType, Byte[] data,
ConverterMethod <TDataType> converter)
{
int dataTypeSize = (int)ExifValue.GetSize(dataType);
int length = data.Length / dataTypeSize;
TDataType[] result = new TDataType[length];
byte[] buffer = new byte[dataTypeSize];
for (int i = 0; i < length; i++)
{
Array.Copy(data, i * dataTypeSize, buffer, 0, dataTypeSize);
result.SetValue(converter(buffer), i);
}
return(result);
}
private static bool isPrimitive(Object _o)
{
if (_o == null)
{
return(true);
}
if (_o is int)
{
return(true);
}
if (_o is long)
{
return(true);
}
if (_o is char)
{
return(true);
}
if (_o is String)
{
return(true);
}
if (_o is Boolean)
{
return(true);
}
if (_o is Enum)
{
return(true);
}
if (_o is Primitivable)
{
return(true);
}
MethodInfo method_ = ConverterMethod.getToStringMethod(_o.GetType());
if (method_ != null)
{
return(true);
}
return(false);
}
public void ExecuteOperation()
{
MoneyConverterClient wcfClient = new MoneyConverterClient();
try
{
ConverterMethod.Invoke(wcfClient);
wcfClient.Close();
}
catch (TimeoutException timeout)
{
// Handle the timeout exception.
wcfClient.Abort();
}
catch (CommunicationException commException)
{
// Handle the communication exception.
wcfClient.Abort();
}
}
public MainWindow(params string[] _args)
{
textBox = new TextBox();
textBox.Multiline = true;
Assembly ass_ = Assembly.Load("ReflectionCore");
Type loadedType_ = ass_.GetType("ReflectionCore.MyClass");
MethodInfo methodFrom_ = ConverterMethod.getFromStringMethod(loadedType_);
MethodInfo methodTo_ = ConverterMethod.getToStringMethod(loadedType_);
object obj_ = methodFrom_.Invoke(null, new object[] { "2" });
MyClass cl_ = obj_ as MyClass;
string text_ = "From " + methodFrom_.Name + " " + cl_.getInteger() + "\r\n";
text_ += "To " + methodTo_.Name + " " + methodTo_.Invoke(cl_, new object[] { }) + "\r\n";
foreach (PropertyInfo f in ConverterMethod.getFields(loadedType_))
{
text_ += f.Name + ": " + f.PropertyType + "\r\n";
}
Type loadedGenericType_ = ass_.GetType("ReflectionCore.GenericType`1");
if (loadedGenericType_ == null)
{
text_ += "type not found: ReflectionCore.GenericType\r\n";
}
else
{
text_ += loadedGenericType_.ToString() + "\r\n";
text_ += loadedGenericType_.BaseType.ToString() + "\r\n";
}
Aliments <Nourriture> n;
n = new Aliments <Nourriture>();
n.Add(new Pomme());
n.Add(new BoudinNoir());
foreach (Nourriture no in n)
{
text_ += no.GetType() + "\r\n";
}
textBox.Text = text_;
textBox.Size = new Size(300, 100);
Controls.Add(textBox);
}
private static TDataType[] ToArray <TDataType>(ExifDataType dataType, ReadOnlySpan <byte> data, ConverterMethod <TDataType> converter)
{
int dataTypeSize = (int)ExifValue.GetSize(dataType);
int length = data.Length / dataTypeSize;
var result = new TDataType[length];
for (int i = 0; i < length; i++)
{
ReadOnlySpan <byte> buffer = data.Slice(i * dataTypeSize, dataTypeSize);
result.SetValue(converter(buffer), i);
}
return(result);
}
public Func <TSource, TTarget> CreateConverter(ModuleBuilder builder)
{
Initialize();
var typeBuilder = builder.DefineStaticType();
var methodBuilder = typeBuilder.DefineStaticMethod("Convert");
methodBuilder.SetReturnType(typeof(TTarget));
methodBuilder.SetParameters(typeof(TSource));
ConverterMethod = methodBuilder;
#if NETSTANDARD
var reflectingTargetType = typeof(TTarget).GetTypeInfo();
var reflectingSourceType = typeof(TSource).GetTypeInfo();
#else
var reflectingTargetType = typeof(TTarget);
var reflectingSourceType = typeof(TSource);
#endif
var il = methodBuilder.GetILGenerator();
var context = new CompilationContext(il);
if (reflectingSourceType.IsValueType)
{
context.SetSource(purpose =>
{
if (purpose == LoadPurpose.MemberAccess)
{
il.Emit(OpCodes.Ldarga_S, 0);
}
else
{
il.Emit(OpCodes.Ldarg_0);
}
});
}
else
{
context.SetSource(purpose => il.Emit(OpCodes.Ldarg_0));
}
var targetLocal = il.DeclareLocal(typeof(TTarget));
_creator.Emit(context);
il.Emit(OpCodes.Stloc, targetLocal);
if (reflectingTargetType.IsValueType)
{
context.SetTarget(
purpose =>
il.Emit(purpose == LoadPurpose.MemberAccess ? OpCodes.Ldloca_S : OpCodes.Ldloc, targetLocal));
}
else
{
context.SetTarget(purpose => il.Emit(OpCodes.Ldloc, targetLocal));
}
EmitMap(context);
context.LoadTarget(LoadPurpose.ReturnValue);
context.Emit(OpCodes.Ret);
#if NETSTANDARD
ConverterMethod = typeBuilder.CreateTypeInfo().GetMethod("Convert", BindingFlags.Static | BindingFlags.Public);
return((Func <TSource, TTarget>)ConverterMethod.CreateDelegate(typeof(Func <TSource, TTarget>)));
#else
ConverterMethod = typeBuilder.CreateType().GetMethod("Convert", BindingFlags.Static | BindingFlags.Public);
return((Func <TSource, TTarget>)Delegate.CreateDelegate(typeof(Func <TSource, TTarget>), ConverterMethod));
#endif
}
private static ElementsSerial createPrimitive(
Object _value, bool _isKey, String _field)
{
if (_value == null)
{
NullSerial null_ = new NullSerial();
null_.setField(_field);
null_.setKeyOfMap(_isKey);
return(null_);
}
MethodInfo method_ = ConverterMethod.getToStringMethod(_value.GetType());
if (method_ != null || _value is Primitivable)
{
StringObjectSerial number_ = new StringObjectSerial(_value);
number_.setKeyOfMap(_isKey);
number_.setField(_field);
return(number_);
}
if (_value is int)
{
NumberSerial <int> number_ = new NumberSerial <int>((int)_value);
number_.setKeyOfMap(_isKey);
number_.setField(_field);
return(number_);
}
if (_value is long)
{
NumberSerial <long> number_ = new NumberSerial <long>((long)_value);
number_.setKeyOfMap(_isKey);
number_.setField(_field);
return(number_);
}
if (_value is String)
{
StringSerial number_ = new StringSerial((String)_value);
number_.setKeyOfMap(_isKey);
number_.setField(_field);
return(number_);
}
if (_value is char)
{
CharacterSerial number_ = new CharacterSerial((char)_value);
number_.setKeyOfMap(_isKey);
number_.setField(_field);
return(number_);
}
if (_value is Boolean)
{
BooleanSerial boolean_ = new BooleanSerial((Boolean)_value);
boolean_.setKeyOfMap(_isKey);
boolean_.setField(_field);
return(boolean_);
}
if (_value is Enum)
{
EnumSerial enum_ = new EnumSerial((Enum)_value);
enum_.setKeyOfMap(_isKey);
enum_.setField(_field);
return(enum_);
}
return(null);
}
