private async void PostButton_Clicked(object sender, EventArgs e)
{//do the if checks
loading.IsRunning = true;
var imgname = typePicker.SelectedItem.ToString() + titleEntry.Text + datePicker.Date.ToString("ddMMMyyyy");
ImgUrl = await App.Online_Db.storeImage_ReturnUrl(file.GetStream(), imgname);
ReflectionModel refModel = new ReflectionModel
{
Author = authorEntry.Text,
ImagesUrl = ImgUrl,
Title = titleEntry.Text,
PostContent = postContentEditor.Text,
PostDate = datePicker.Date,
PostType = (Model.Type)Enum.Parse(typeof(Model.Type), typePicker.SelectedItem.ToString()),
};
await App.Online_Db.AddReflection(refModel);
await DisplayAlert("Success", "Reflection posted successfully", "OK");
loading.IsRunning = false;
await Navigation.PopModalAsync(true);
await DisplayAlert("page pop", "one", "OK");
await Navigation.PopAsync(true);
}
public void NamespacesTest()
{
ReflectionModel reflect = new ReflectionModel(Path.GetFullPath(URL));
Assert.AreEqual("ExampleDLL", reflect.Namespaces.Find(x => x.Name == "ExampleDLL").Name);
Assert.AreEqual("ExampleDLL.Animals", reflect.Namespaces.Find(x => x.Name == "ExampleDLL.Animals").Name);
}
public ReflectionViewPage(ReflectionModel reflection)
{
InitializeComponent();
this.Title = reflection.PostType + " Reflection";
PostTitle.Text = reflection.Title;
PostAuthorDate.Text = reflection.Author_Date;
PostImage.Source = reflection.ImagesUrl;
PostContent.Text = reflection.PostContent;
}
/// <summary>
/// Generates a document model from a <see cref="ReflectionModel"/>
/// and a <see cref="XmlDocumentationModel"/>.
/// </summary>
/// <param name="reflectionModel">The reflection model.</param>
/// <param name="xmlModel">The XML documentation model.</param>
/// <returns>A document model.</returns>
public static DocumentModel Map(ReflectionModel reflectionModel, XmlDocumentationModel xmlModel)
{
var assemblies = new List <DocumentedAssembly>();
// Iterate all assemblies.
foreach (var assembly in reflectionModel.Assemblies)
{
assemblies.Add(MapAssembly(assembly, xmlModel));
}
return(new DocumentModel(assemblies));
}
public void InterfacesTest()
{
ReflectionModel reflect = new ReflectionModel(Path.GetFullPath(URL));
ReflectedType a_interface = (from names in reflect.Namespaces
from inter in names.Interfaces
select inter).First();
Assert.AreEqual("ISpeaking", a_interface.Name);
Assert.IsTrue(a_interface.IsAbstract);
Assert.AreEqual(a_interface.TypeKind.ToString(), "Interface");
}
public void DictionaryTest()
{
ReflectionModel model = new ReflectionModel(Path.GetFullPath(URL));
Assert.IsTrue(SingletonDictionary <ReflectedType> .Types.ContainsKey("Cat"));
Assert.IsTrue(SingletonDictionary <ReflectedType> .Types.ContainsKey("Dog"));
Assert.IsTrue(SingletonDictionary <ReflectedType> .Types.ContainsKey("Animal"));
Assert.IsTrue(SingletonDictionary <ReflectedType> .Types.ContainsKey("Person"));
Assert.IsTrue(SingletonDictionary <ReflectedType> .Types.ContainsKey("Woman"));
Assert.IsTrue(SingletonDictionary <ReflectedType> .Types.ContainsKey("StaticClass"));
Assert.IsTrue(SingletonDictionary <ReflectedType> .Types.ContainsKey("PrivateClass"));
}
/// <summary>
/// Generates a document model from a <see cref="ReflectionModel"/>
/// and a <see cref="XmlDocumentationModel"/>.
/// </summary>
/// <param name="reflectionModel">The reflection model.</param>
/// <param name="xmlModel">The XML documentation model.</param>
/// <returns>A document model.</returns>
public static DocumentModel Map(ReflectionModel reflectionModel, XmlDocumentationModel xmlModel)
{
var assemblies = new List <DocumentedAssembly>();
// Iterate all assemblies.
foreach (var assembly in reflectionModel.Assemblies)
{
assemblies.Add(MapAssembly(assembly, xmlModel));
}
// Create the document model.
var model = new DocumentModel(assemblies);
// Map extension methods.
var finder = new ExtensionMethodFinder(model);
var namespaces = model.Assemblies.SelectMany(a => a.Namespaces).ToArray();
foreach (var @namespace in namespaces)
{
foreach (var type in @namespace.Types)
{
type.SetExtensionMethods(finder.FindExtensionMethods(type));
}
}
// Map base types methods.
var baseTypeFinder = new BaseTypeFinder(model);
foreach (var @namespace in namespaces)
{
foreach (var type in @namespace.Types)
{
type.BaseType = baseTypeFinder.FindBaseType(type);
}
}
// Build namespace trees and map them.
var trees = DocumentedNamespaceTree.Build(namespaces);
foreach (var @namespace in namespaces)
{
if (trees.ContainsKey(@namespace.Identity))
{
@namespace.Tree = trees[@namespace.Identity];
}
}
return(model);
}
public DailyViewPage(ReflectionModel reflection)
{
InitializeComponent();
PostTitle.Text = reflection.Title;
PostAuthorDate.Text = reflection.Author_Date;
PostImage.Source = reflection.ImagesUrl;
PostContent.Text = reflection.PostContent;
List <somethinges> things = new List <somethinges>
{
new somethinges {
Title = "This", Author = "That"
},
new somethinges {
Title = "This", Author = "That"
},
new somethinges {
Title = "This", Author = "That"
},
new somethinges {
Title = "This", Author = "That"
},
new somethinges {
Title = "This", Author = "That"
},
new somethinges {
Title = "This", Author = "That"
},
new somethinges {
Title = "This", Author = "That"
},
new somethinges {
Title = "This", Author = "That"
},
new somethinges {
Title = "This", Author = "That"
},
new somethinges {
Title = "This", Author = "That"
},
new somethinges {
Title = "This", Author = "That"
}
};
// carousel.ItemsSource = things.AsEnumerable();
}
public void ClassesNamesTest()
{
ReflectionModel reflect = new ReflectionModel(Path.GetFullPath(URL));
IEnumerable <string> tmp_names = from names in reflect.Namespaces
from classes in names.Classes
select classes.Name;
Assert.AreEqual(tmp_names.ToList().Find(x => x == "Cat"), "Cat");
Assert.AreEqual(tmp_names.ToList().Find(x => x == "Dog"), "Dog");
Assert.AreEqual(tmp_names.ToList().Find(x => x == "Animal"), "Animal");
Assert.AreEqual(tmp_names.ToList().Find(x => x == "Person"), "Person");
Assert.AreEqual(tmp_names.ToList().Find(x => x == "StaticClass"), "StaticClass");
Assert.AreEqual(tmp_names.ToList().Find(x => x == "Woman"), "Woman");
Assert.AreEqual(tmp_names.ToList().Find(x => x == "PrivateClass"), "PrivateClass");
}
public static TempReflection ObjectFelds(object obj)
{
var fs = obj.GetType().GetFields();
TempReflection temp = new TempReflection();
temp.Top = fs.Length;
ReflectionModel[] reflections = new ReflectionModel[temp.Top];
for (int i = 0; i < fs.Length; i++)
{
ReflectionModel r = new ReflectionModel();
r.field = fs[i];
r.FieldType = fs[i].FieldType;
r.name = fs[i].Name;
reflections[i] = r;
}
temp.All = reflections;
return(temp);
}
public void ValueTypeTest()
{
ReflectionModel reflecion = new ReflectionModel(Path.GetFullPath(URL));
ReflectedType reflectedType = reflecion.Namespaces.Find(x => x.Name == "ExampleDLL").ValueTypes.Find(x => x.Name == "Point");
Assert.AreEqual("Point", reflectedType.Name);
Assert.AreEqual("ExampleDLL", reflectedType.Namespace);
Assert.AreEqual("ValueType", reflectedType.BaseType.Name);
Assert.AreEqual("x", reflectedType.Fields[0].Name);
Assert.AreEqual(AccessModifier.Private, reflectedType.Fields[0].Access);
Assert.AreEqual("Int32", reflectedType.Fields[0].Type.Name);
Assert.AreEqual("y", reflectedType.Fields[1].Name);
Assert.AreEqual(AccessModifier.Private, reflectedType.Fields[1].Access);
Assert.AreEqual("Int32", reflectedType.Fields[1].Type.Name);
Assert.AreEqual("GetX", reflectedType.Methods.Find(x => x.Name == "GetX").Name);
Assert.AreEqual("GetY", reflectedType.Methods.Find(x => x.Name == "GetY").Name);
Assert.AreEqual("Equals", reflectedType.Methods.Find(x => x.Name == "Equals").Name);
Assert.AreEqual("GetHashCode", reflectedType.Methods.Find(x => x.Name == "GetHashCode").Name);
Assert.AreEqual("ToString", reflectedType.Methods.Find(x => x.Name == "ToString").Name);
Assert.AreEqual("GetType", reflectedType.Methods.Find(x => x.Name == "GetType").Name);
Assert.AreEqual(6, reflectedType.Methods.Count);
}
public void ClassTest()
{
ReflectionModel reflect = new ReflectionModel(Path.GetFullPath(URL));
ReflectedType cat = (from names in reflect.Namespaces
from classes in names.Classes
where classes.Name == "Cat"
select classes).First();
Assert.AreEqual("Sound", cat.Methods.Find(x => x.Name == "Sound").Name);
Assert.AreEqual(AccessModifier.Public, cat.Methods.Find(x => x.Name == "Sound").Access);
Assert.AreEqual("String", cat.Methods.Find(x => x.Name == "Sound").ReturnType.Name);
Assert.AreEqual("Int32", cat.Methods.Find(x => x.Name == "Sound").Parameters.First().ParamType.Name);
Assert.AreEqual(AccessModifier.Public, cat.Access);
Assert.IsFalse(cat.IsAbstract);
Assert.IsFalse(cat.IsStatic);
Assert.AreEqual(Kind.Class, cat.TypeKind);
Assert.AreEqual("ISpeaking", cat.ImplementedInterfaces.First().Name);
Assert.AreEqual(1, cat.Constructors.Count);
Assert.AreEqual("ExampleDLL.Animals", cat.Namespace);
Assert.IsTrue(cat.Properties.Exists(x => x.Name == "Name"));
Assert.AreEqual("Animal", cat.BaseType.Name);
}
public async Task AddReflection(ReflectionModel reflectionModel)
{
await firebaseClient
.Child("Reflections")
.PostAsync <ReflectionModel>(reflectionModel);
}
