public static CDefinitionMethodeDynamique GetDefinitionMethode(Type tp, string strMethode)
{
MethodInfo info = tp.GetMethod(strMethode);
if (info == null)
{
return(null);
}
object[] attribs = info.GetCustomAttributes(typeof(DynamicMethodAttribute), true);
if (attribs.Length == 1)
{
DynamicMethodAttribute attrib = (DynamicMethodAttribute)attribs[0];
CTypeResultatExpression typeRes = CTypeResultatExpression.FromTypeDotNet(info.ReturnType);
CDefinitionMethodeDynamique def = new CDefinitionMethodeDynamique(
info.Name,
info.Name,
typeRes,
CFournisseurGeneriqueProprietesDynamiques.HasSubProperties(typeRes.TypeDotNetNatif),
attrib.Descriptif,
attrib.InfosParametres);
def.Rubrique = I.T("Methods|58");
return(def);
}
return(null);
}
public CDefinitionProprieteDynamique[] GetDefinitionsChamps(CObjetPourSousProprietes objet, CDefinitionProprieteDynamique defParente)
{
List <CDefinitionProprieteDynamique> lstProps = new List <CDefinitionProprieteDynamique>();
if (objet == null)
{
return(lstProps.ToArray());
}
Type tp = objet.TypeAnalyse;
if (tp == null)
{
return(lstProps.ToArray());
}
//Va chercher les propriétés
foreach (MethodInfo methode in tp.GetMethods())
{
object[] attribs = methode.GetCustomAttributes(typeof(DynamicMethodAttribute), true);
if (attribs.Length == 1)
{
DynamicMethodAttribute attrib = (DynamicMethodAttribute)attribs[0];
CTypeResultatExpression typeRes = CTypeResultatExpression.FromTypeDotNet(methode.ReturnType);
ParameterInfo[] parametres = methode.GetParameters();
StringBuilder bl = new StringBuilder();
bl.Append(methode.Name);
bl.Append("(");
foreach (ParameterInfo info in parametres)
{
bl.Append(info.Name);
bl.Append("; ");
}
if (parametres.Length > 0)
{
bl.Remove(bl.Length - 2, 2);
}
bl.Append(")");
CDefinitionProprieteDynamique def = new CDefinitionMethodeDynamique(
bl.ToString(),
methode.Name,
typeRes,
CFournisseurGeneriqueProprietesDynamiques.HasSubProperties(typeRes.TypeDotNetNatif),
attrib.Descriptif,
attrib.InfosParametres);
def.Rubrique = I.T("Methods|58");
lstProps.Add(def);
}
}
foreach (CMethodeSupplementaire methode in CGestionnaireMethodesSupplementaires.GetMethodsForType(tp))
{
CDefinitionProprieteDynamique def = new CDefinitionMethodeDynamique(
methode.Name,
methode.Name,
new CTypeResultatExpression(methode.ReturnType, methode.ReturnArrayOfReturnType),
CFournisseurGeneriqueProprietesDynamiques.HasSubProperties(methode.ReturnType));
def.Rubrique = I.T("Methods|58");
lstProps.Add(def);
}
return(lstProps.ToArray());
}
/// //////////////////////////////////// /////////////////////////////////
public C2iExpressionMethodeDynamique(CDefinitionMethodeDynamique DefinitionMethode)
{
m_definitionMethode = DefinitionMethode;
if (DefinitionMethode != null)
{
m_strNomMethode = DefinitionMethode.NomProprieteSansCleTypeChamp;
}
}
/// /////////////////////////////////////////////////
/// Le data du result contient l'expression
protected override CResultAErreur GetExpressionMethode(string strMethode)
{
CDefinitionMethodeDynamique definitionMethode = null;
CDefinitionFonctionDynamique definitionFonction = null;
CResultAErreur result = CResultAErreur.True;
if (m_contexteAnalyse.FournisseurProprietes == null)
{
result.EmpileErreur(I.T("The property supplier parser cannot recognize the methods|144"));
return(result);
}
else
{
if (!IsAnalyseExpressionObjet())
{
string strNomUpper = strMethode.ToUpper();
foreach (CDefinitionProprieteDynamique def in m_contexteAnalyse.GetDefinitionsChamps(m_contexteAnalyse.ObjetAnalyse))
{
if (def is CDefinitionMethodeDynamique)
{
if (def.Nom.ToUpper() == strNomUpper || def.NomPropriete.ToUpper() == strNomUpper)
{
definitionMethode = (CDefinitionMethodeDynamique)def;
break;
}
}
if (def is CDefinitionFonctionDynamique)
{
if (def.NomPropriete.ToUpper() == strNomUpper)
{
definitionFonction = (CDefinitionFonctionDynamique)def;
break;
}
}
}
}
/*if ( definitionMethode == null )
* {
* //Définition temporaire, elle n'existe pas dans le type de base
* definitionMethode = new CDefinitionMethodeDynamique(strMethode, strMethode, null, false);
* }*/
if (definitionFonction != null)
{
result.Data = new C2iExpressionMethodeDynamique(definitionFonction);
}
else if (definitionMethode != null)
{
result.Data = new C2iExpressionMethodeDynamique(definitionMethode);
}
else
{
result.Data = new C2iExpressionMethodeDynamique(strMethode);
}
return(result);
}
}
//----------------------------------------------------------
/// <summary>
/// Le data du result contient la valeur de la propriété pour l'objet
/// </summary>
/// <param name="objet"></param>
/// <param name="strPropriete"></param>
/// <returns></returns>
public static string[] GetProprietesAccedees(Type typeSource, string strProprieteComplete)
{
string strSuitePropriete = "";
List <string> lstProps = new List <string>();
string strProprieteCompleteOriginale = strProprieteComplete;
string strChemin = "";
do
{
strSuitePropriete = "";
string[] strProprietes = strProprieteComplete.Split('.');
string strPropriete = strProprietes[0];
if (strProprieteComplete.Length > strPropriete.Length)
{
strSuitePropriete = strProprieteComplete.Substring(strPropriete.Length + 1);
}
string strCleType = "";
string strProprieteSansCle = "";
if (CDefinitionMethodeDynamique.DecomposeNomProprieteUnique(strPropriete, ref strCleType, ref strProprieteSansCle))
{
Type tpInterpreteur = null;
if (m_tableCleTypeToTypeInterpreteur.TryGetValue(strCleType.ToUpper(), out tpInterpreteur))
{
IInterpreteurProprieteDynamiqueAccedantADautresProprietes interpreteur = Activator.CreateInstance(tpInterpreteur) as IInterpreteurProprieteDynamiqueAccedantADautresProprietes;
if (interpreteur != null)
{
CArbreDefinitionsDynamiques arbreProps = new CArbreDefinitionsDynamiques(null);
interpreteur.AddProprietesAccedees(arbreProps, typeSource, strProprieteSansCle);
foreach (string strProp in arbreProps.GetListeProprietesAccedees())
{
lstProps.Add(strChemin + strProp);
}
}
else
{
lstProps.Add(strChemin + strPropriete);
}
strChemin += strPropriete + ".";
}
else
{
strChemin += strPropriete + ".";
}
strProprieteComplete = strSuitePropriete;
}
else
{
return(lstProps.ToArray());
}
}while (strSuitePropriete.Length > 0);
return(lstProps.ToArray());
}
/// //////////////////////////////////// /////////////////////////////////
public override CResultAErreur SetTypeObjetInterroge(CObjetPourSousProprietes objetPourProprietes, IFournisseurProprietesDynamiques fournisseur)
{
CResultAErreur result = base.SetTypeObjetInterroge(objetPourProprietes, fournisseur);
if (!result)
{
return(result);
}
ObjetPourAnalyseSourceConnu = objetPourProprietes;
if (objetPourProprietes == null)
{
return(result);
}
if (DefinitionMethode != null)
{
return(result);
}
if (DefinitionFonction != null)
{
return(result);
}
string strNomUpper = m_strNomMethode.ToUpper();
foreach (CDefinitionProprieteDynamique prop in fournisseur.GetDefinitionsChamps(objetPourProprietes))
{
if (prop is CDefinitionMethodeDynamique)
{
if (prop.NomProprieteSansCleTypeChamp.ToUpper() == strNomUpper ||
prop.Nom.ToUpper() == strNomUpper)
{
m_definitionMethode = (CDefinitionMethodeDynamique)prop;
return(result);
}
}
if (prop is CDefinitionFonctionDynamique)
{
if (prop.NomProprieteSansCleTypeChamp.ToUpper() == strNomUpper ||
prop.Nom.ToUpper() == strNomUpper)
{
m_definitionFonction = (CDefinitionFonctionDynamique)prop;
return(result);
}
}
}
result.EmpileErreur(I.T("The @1 method doesn't exit in the @2 type|120", m_strNomMethode,
objetPourProprietes != null? objetPourProprietes.ToString():"null"));
return(result);
}
//----------------------------------------------------------
/// <summary>
/// Le data du result contient la valeur de la propriété pour l'objet
/// </summary>
/// <param name="objet"></param>
/// <param name="strPropriete"></param>
/// <returns></returns>
public static IOptimiseurGetValueDynamic GetOptimiseur(Type tp, string strProprieteComplete)
{
COptimiseurGetValueDynamicMultiple optimiseur = new COptimiseurGetValueDynamicMultiple();
string strSuitePropriete = "";
do
{
strSuitePropriete = "";
string[] strProprietes = strProprieteComplete.Split('.');
string strPropriete = strProprietes[0];
if (strProprieteComplete.Length > strPropriete.Length)
{
strSuitePropriete = strProprieteComplete.Substring(strPropriete.Length + 1);
}
string strCleType = "";
string strProprieteSansCle = "";
if (CDefinitionMethodeDynamique.DecomposeNomProprieteUnique(strPropriete, ref strCleType, ref strProprieteSansCle))
{
strPropriete = strProprieteSansCle;
Type tpInterpreteur = null;
if (m_tableCleTypeToTypeInterpreteur.TryGetValue(strCleType.ToUpper(), out tpInterpreteur))
{
IInterpreteurProprieteDynamique interpreteur = Activator.CreateInstance(tpInterpreteur) as IInterpreteurProprieteDynamique;
if (interpreteur != null)
{
IOptimiseurGetValueDynamic sousOptim = interpreteur.GetOptimiseur(tp, strPropriete);
if (sousOptim == null)
{
return(null);
}
optimiseur.AddOptimiseur(sousOptim);
tp = optimiseur.GetTypeRetourne();
}
}
else
{
return(null);
}
strProprieteComplete = strSuitePropriete;
}
else
{
return(null);
}
}while (strSuitePropriete.Length > 0);
return(optimiseur);
}
public static CResultAErreur SetValue(object objet, string strPropriete, object valeur)
{
CResultAErreur result = CResultAErreur.True;
//Nettoie la propriété pour enlever les éléments de fin qui ne sont pas
//à prendre en compte lors d'un SetValue
strPropriete = NettoieProprieteSetValue(strPropriete);
//Récupère la valeur source
int nPos = strPropriete.LastIndexOf('.');
string strLastProp = strPropriete;
if (nPos > 0)
{
strLastProp = strPropriete.Substring(nPos + 1);
string strPropDebut = strPropriete.Substring(0, nPos);
result = GetValue(objet, strPropDebut);
if (!result)
{
return(result);
}
objet = result.Data;
}
if (objet == null)
{
result.EmpileErreur(I.T("Trying to affect a value to a null object |20002"));
return(result);
}
string strCleType = "";
string strProprieteSansCle = "";
if (CDefinitionMethodeDynamique.DecomposeNomProprieteUnique(strLastProp, ref strCleType, ref strProprieteSansCle))
{
Type tpInterpreteur = null;
if (m_tableCleTypeToTypeInterpreteur.TryGetValue(strCleType.ToUpper(), out tpInterpreteur))
{
IInterpreteurProprieteDynamique interpreteur = Activator.CreateInstance(tpInterpreteur) as IInterpreteurProprieteDynamique;
if (interpreteur != null)
{
return(interpreteur.SetValue(objet, strProprieteSansCle, valeur));
}
}
}
result.EmpileErreur(I.T("Bad property format (@1)|20000", strPropriete));
return(result);
}
/// //////////////////////////////////// /////////////////////////////////
public override CResultAErreur Serialize(C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
result = base.Serialize(serializer);
if (!result)
{
return(result);
}
I2iSerializable obj = m_definitionMethode;
result = serializer.TraiteObject(ref obj);
if (!result)
{
return(result);
}
m_definitionMethode = (CDefinitionMethodeDynamique)obj;
if (nVersion >= 1)
{
result = serializer.TraiteObject <CDefinitionFonctionDynamique>(ref m_definitionFonction);
}
if (serializer.Mode == ModeSerialisation.Lecture)
{
if (m_definitionFonction != null)
{
m_strNomMethode = m_definitionFonction.NomProprieteSansCleTypeChamp;
}
if (m_definitionMethode != null)
{
m_strNomMethode = m_definitionMethode.NomProprieteSansCleTypeChamp;
}
}
return(result);
}