private object GetAnnotationValue(IEdmElement element, string namespaceName, string localName, VersioningDictionary <IEdmElement, object> annotationsDictionary)
{
object value;
IEdmDirectValueAnnotation edmDirectValueAnnotation = EdmDirectValueAnnotationsManager.FindTransientAnnotation(EdmDirectValueAnnotationsManager.GetTransientAnnotations(element, annotationsDictionary), namespaceName, localName);
if (edmDirectValueAnnotation == null)
{
IEnumerable <IEdmDirectValueAnnotation> attachedAnnotations = this.GetAttachedAnnotations(element);
if (attachedAnnotations != null)
{
IEnumerator <IEdmDirectValueAnnotation> enumerator = attachedAnnotations.GetEnumerator();
using (enumerator)
{
while (enumerator.MoveNext())
{
IEdmDirectValueAnnotation current = enumerator.Current;
if (!(current.NamespaceUri == namespaceName) || !(current.Name == localName))
{
continue;
}
value = current.Value;
return(value);
}
return(null);
}
return(value);
}
return(null);
}
else
{
return(edmDirectValueAnnotation.Value);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="EdmModelBase"/> class.
/// </summary>
/// <param name="referencedModels">Models to which this model refers.</param>
/// <param name="annotationsManager">Annotations manager for the model to use.</param>
protected EdmModelBase(IEnumerable<IEdmModel> referencedModels, EdmDirectValueAnnotationsManager annotationsManager)
{
EdmUtil.CheckArgumentNull(referencedModels, "referencedModels");
EdmUtil.CheckArgumentNull(annotationsManager, "annotationsManager");
this.referencedModels = new List<IEdmModel>(referencedModels);
this.referencedModels.Add(EdmCoreModel.Instance);
this.annotationsManager = annotationsManager;
}
private void SetAnnotationValue(IEdmElement element, string namespaceName, string localName, object value, ref VersioningDictionary <IEdmElement, object> annotationsDictionary)
{
object transientAnnotations = EdmDirectValueAnnotationsManager.GetTransientAnnotations(element, annotationsDictionary);
object obj = transientAnnotations;
EdmDirectValueAnnotationsManager.SetAnnotation(this.GetAttachedAnnotations(element), ref transientAnnotations, namespaceName, localName, value);
if (transientAnnotations != obj)
{
annotationsDictionary = annotationsDictionary.Set(element, transientAnnotations);
}
}
protected EdmModelBase(IEnumerable<IEdmModel> referencedModels, EdmDirectValueAnnotationsManager annotationsManager)
{
this.containersDictionary = new Dictionary<string, IEdmEntityContainer>();
this.schemaTypeDictionary = new Dictionary<string, IEdmSchemaType>();
this.valueTermDictionary = new Dictionary<string, IEdmValueTerm>();
this.functionDictionary = new Dictionary<string, object>();
EdmUtil.CheckArgumentNull<IEnumerable<IEdmModel>>(referencedModels, "referencedModels");
EdmUtil.CheckArgumentNull<EdmDirectValueAnnotationsManager>(annotationsManager, "annotationsManager");
this.referencedModels = new List<IEdmModel>(referencedModels);
this.referencedModels.Add(EdmCoreModel.Instance);
this.annotationsManager = annotationsManager;
}
public CsdlSemanticsModel(CsdlModel astModel, EdmDirectValueAnnotationsManager annotationsManager, IEnumerable<IEdmModel> referencedModels) : base(referencedModels, annotationsManager)
{
this.schemata = new List<CsdlSemanticsSchema>();
this.outOfLineAnnotations = new Dictionary<string, List<CsdlSemanticsAnnotations>>();
this.wrappedAnnotations = new Dictionary<CsdlVocabularyAnnotationBase, CsdlSemanticsVocabularyAnnotation>();
this.associationDictionary = new Dictionary<string, IEdmAssociation>();
this.derivedTypeMappings = new Dictionary<string, List<IEdmStructuredType>>();
this.astModel = astModel;
foreach (CsdlSchema schema in this.astModel.Schemata)
{
this.AddSchema(schema);
}
}
public IEnumerable <IEdmDirectValueAnnotation> GetDirectValueAnnotations(IEdmElement element)
{
VersioningDictionary <IEdmElement, object> versioningDictionary = this.annotationsDictionary;
IEnumerable <IEdmDirectValueAnnotation> attachedAnnotations = this.GetAttachedAnnotations(element);
object obj = EdmDirectValueAnnotationsManager.GetTransientAnnotations(element, versioningDictionary);
if (attachedAnnotations != null)
{
foreach (IEdmDirectValueAnnotation attachedAnnotation in attachedAnnotations)
{
if (EdmDirectValueAnnotationsManager.IsDead(attachedAnnotation.NamespaceUri, attachedAnnotation.Name, obj))
{
continue;
}
yield return(attachedAnnotation);
}
}
foreach (IEdmDirectValueAnnotation edmDirectValueAnnotation in EdmDirectValueAnnotationsManager.TransientAnnotations(obj))
{
yield return(edmDirectValueAnnotation);
}
}
private static void SetAnnotation(IEnumerable <IEdmDirectValueAnnotation> immutableAnnotations, ref object transientAnnotations, string namespaceName, string localName, object value)
{
IEdmDirectValueAnnotation edmDirectValueAnnotation;
Func <IEdmDirectValueAnnotation, bool> func = null;
bool flag = false;
if (immutableAnnotations != null)
{
IEnumerable <IEdmDirectValueAnnotation> edmDirectValueAnnotations = immutableAnnotations;
if (func == null)
{
func = (IEdmDirectValueAnnotation existingAnnotation) => {
if (existingAnnotation.NamespaceUri != namespaceName)
{
return(false);
}
else
{
return(existingAnnotation.Name == localName);
}
}
;
}
if (edmDirectValueAnnotations.Any <IEdmDirectValueAnnotation>(func))
{
flag = true;
}
}
if (value != null || flag)
{
if (!(namespaceName == "http://schemas.microsoft.com/ado/2011/04/edm/documentation") || value == null || value as IEdmDocumentation != null)
{
if (value != null)
{
edmDirectValueAnnotation = new EdmDirectValueAnnotation(namespaceName, localName, value);
}
else
{
edmDirectValueAnnotation = new EdmDirectValueAnnotation(namespaceName, localName);
}
IEdmDirectValueAnnotation edmDirectValueAnnotation1 = edmDirectValueAnnotation;
if (transientAnnotations != null)
{
IEdmDirectValueAnnotation edmDirectValueAnnotation2 = transientAnnotations as IEdmDirectValueAnnotation;
if (edmDirectValueAnnotation2 == null)
{
VersioningList <IEdmDirectValueAnnotation> edmDirectValueAnnotations1 = (VersioningList <IEdmDirectValueAnnotation>)transientAnnotations;
int num = 0;
while (num < edmDirectValueAnnotations1.Count)
{
IEdmDirectValueAnnotation item = edmDirectValueAnnotations1[num];
if (!(item.NamespaceUri == namespaceName) || !(item.Name == localName))
{
num++;
}
else
{
edmDirectValueAnnotations1 = edmDirectValueAnnotations1.RemoveAt(num);
break;
}
}
transientAnnotations = edmDirectValueAnnotations1.Add(edmDirectValueAnnotation1);
return;
}
else
{
if (!(edmDirectValueAnnotation2.NamespaceUri == namespaceName) || !(edmDirectValueAnnotation2.Name == localName))
{
transientAnnotations = VersioningList <IEdmDirectValueAnnotation> .Create().Add(edmDirectValueAnnotation2).Add(edmDirectValueAnnotation1);
return;
}
else
{
transientAnnotations = edmDirectValueAnnotation1;
return;
}
}
}
else
{
transientAnnotations = edmDirectValueAnnotation1;
return;
}
}
else
{
throw new InvalidOperationException(Strings.Annotations_DocumentationPun(value.GetType().Name));
}
}
else
{
EdmDirectValueAnnotationsManager.RemoveTransientAnnotation(ref transientAnnotations, namespaceName, localName);
return;
}
}
private static bool IsDead(string namespaceName, string localName, object transientAnnotations)
{
return(EdmDirectValueAnnotationsManager.FindTransientAnnotation(transientAnnotations, namespaceName, localName) != null);
}
