We Keep Coding

C# - Can a Method Examine Another Method's Use of a Parameter?

I have a variety of methods that use a configuration object to fill in placeholders in a template. Different methods use different subsets of properties of the configuration object. I'd like an easy way to check that all the properties a given method uses are present in a given config object.
Right now I have a method like this:
private static void ValidateConfiguration(CustomerConfiguration config, params string[] properties)
This has the maintenance disadvantage that it relies on a separate set of strings for the properties used. What I'd love to do is have the validation method look at the calling method and see what properties of the config object are being accessed. Can this be done?
(I could also wrap String.Replace() in a method that checks for nulls, but that's less fun.)

A type safe way to handle your problem would be to implement several interfaces with different meaningful subsets of properties. My understanding is that the presence/absence of the properties in your case depends on the type of configuration object and is dynamic.
you could use a signature like that
ValidateConfiguration<T>(CustomerConfiguration config)
where T represent the interface and use reflection to list the required properties. While it would be practically impossible to parse the code of a method to infer its usages of a data structure, reflection on types (to extract properties) is fairly easy.

Different methods use different subsets of properties of the configuration object.
If you're only creating one instance of the configuration property, then the properties it needs to have are whichever ones are going to be used by any method. In other words, if at least one method needs that property, then the object needs that property.
In that case there's no need to validate it in relation to individual methods that need it. All of its properties need to be populated because they're all needed somewhere. If they're not needed anywhere, you can delete them.
Then, instead of validating that object based on the needs of a particular method, you validate it once, perhaps at startup. All of the properties are needed, so if they haven't been specified then the application just can't run. (Sometimes it's good to include defaults in your configuration object. You might have one property that you want to be able to configure, but in real life it's never going to change.)
If you're creating different instances of the same object for use in different methods and you only want to populate certain properties then it's better not to do that. Just create more granular objects for different scenarios containing all the properties you need.
What frequently happens is this: We have an object with lots of properties and we only use a few of them, so we populate those properties and pass the object to a method. The other properties are null.
Then, someone modifying that method decides that they need another property, so they try to use it, and they're surprised to find out that it's null. Then they have to go back and trace where that object was created and figure out what is populated or not. That's confusing and time-consuming.
Unless fields are entirely optional and it doesn't matter whether they are populated or not, we don't want to find ourselves looking at an object with lots of properties and guessing which ones have been populated because individual methods that create the object "know" which properties other classes do or don't need.

Create object names dynamically

I am building web service in C# for a particular application, I have a XML definition of module. I have created a class called Field that holds the properties of all fields on a module. What I would like to do is create the field objects but name them dynamically then add them to a list of some sort. So when I reference them from the client it would be like this:
Module.Fields.MyDynamicName.FieldProperty
Is this possible to do? and could anyone point me in the right direction on how to do this.
Hope my question makes sense.

Basically you need to design for "deferred design", which means you do not know at compile time what the design is, but you still need to accommodate it.
There are probably a few ways but what I have done in the past is use a dictionary list of Key/Value pairs to store fields. Using serialization (I prefer Json) you can shove just about anything into a string and store it as the Value, then deserialize it when you need it.

How to use Projections with references?

I have a mapping that has two references to two other mappings.
Firstly, would I create sub-criteria or create aliases?
So I have:
Base.Property1
Base.Property2
Base.Reference1.Property1
Base.Reference1.Property2
Base.Reference2.Property1
Base.Reference2.Property2
I want to project my query to just these 6 properties.
I have managed to use Projections on a query on just one table, but I'm having difficulty when it comes to multiple tables.
would I do something like (for each reference):
criteria.CreateCrtieria(bla)
.SetProjection(Projections.ProjectionList()
.Add(/*Add projections*/))
.SetResultTransformer(Transformers.AliasToBean(type));
Or just create aliases and have projections on the original criteria like so:
criteria.CreateAlias("reference1", "r1").CreateAlias("reference2", "r2")
.SetProjection(Projections.ProjectionList()
.Add(Projections.Property("baseProperty1")
.Add(Projections.Property("r1.property1")
.Add(Projections.Property("r2.property2")) /*etc*/
.SetResultTransformer(Transformers.AliasToBean(baseType));
I don't know if the previous two ideas actually work - they don't seem to, but I don't know if that's because I've forgotten something or if they're along totally the wrong lines.
Thanks.

Using the CreateAlias methods on the Criteria API allow you to join across to your referenced objects and allow you to project out the properties.
You assign each referenced type an alias which you then use to access the properties of the referenced objects.
Also please be aware that you need to make sure the names of the properties in the object you are projecting into are an exact match in the projection list.
You can also specify the JoinType on the CreateAlias methods as well should you want to force a InnerJoin instead of a LeftJoin.
var query = session.CreateCriteria<Base>()
.CreateAlias("Base.Reference1","ref1")
.CreateAlias("Base.Reference2","ref2")
.SetProjection(
Projections.ProjectionList()
.Add(Projections.Property("Base.BaseProperty"),"DtoBaseProperty")
.Add(Projections.Property("ref1.property1"),"DtoProperty1")
.Add(Projections.Property("ref2.property2"),"DtoProperty2")
)
.SetResultTransFormer(Transformers.AliasToBean(typeof(ProjectionDto)))
.List<ProjectionDto>();
public class ProjectionDto{
public string DtoBaseProperty;
public string DtoProperty1;
public string DtoProperty2;
}

My solution ended up requiring me to write a new Transformer. I'm not going to paste the code because it's fairly long and at the moment quite hacky. But for anyone interested:
Rather than doing .Add(Projections.Property("r1.property1")
I did .Add(Projections.Property("r1.property1"), "SubType.Property1")
Then in the transformer the alias "SubType.Property1" has a tuple value associated with it. I split the alias up and construct a SubType, and for any aliases associated with it, do the same as what the existing transformer does (assign values to those properties on that type), and then finally set the subtype object as a value to the property on the base type.
It's probably completely against the concept of Projections but it works, and works quite well, considering it was hacked together in a couple of hours.

Building a string representation of an object using a "mask" or user supplied Format String

I'm not really sure what tags should be on this sort of question so feel free to give me some suggestions if you think some others are more suited.
I have a dynamic object with an unknown number or properties on it, it's from a sort of dynamic self describing data model that lets the user build the data model at runtime. However because all of the fields holding relevant information to the user are in dynamic properties, it's difficult to determine what should be the human readable identifier, so it's left up to the administrator. (Don't think it matters but this is an ASP.NET MVC3 Application). To help during debugging I had started decorating some classes with DebuggerDisplayAttribute to make it easier to debug. This allow me to do things like
[DebuggerDisplay(#"\{Description = {Description}}")]
public class Group
to get a better picture of what a specific instance of an object is. And this sort of setup would be perfect but I can't seem to find the implementation of this flexibility. This is especially useful on my dynamic objects because the string value of the DebuggerDisplayAttribute is resolved by the .NET framework and I have implementations of TryGetMember on my base object class to handle the dynamic aspect. But this only makes it easier for development. So I've added a field on what part of my object is still strongly typed and called it Title, and I'd like to let the administer set the implementation using their own format, so to speak. So for example they might build out a very simplistic rental tracking system to show rentals and they might specify a format string along the lines of
"{MovieTitle} (Due: {DueDate})"
I would like that when they save the record to add some logic to first update the Title property by resolving the format string to substitute each place holder with the value of the appropriate property on the dynamic object. So this might resolve to a title of
"Inception (Due: May 21, 2011)", or a more realistic scenario of a format string of
"{LastName}, {FirstName}"
I don't want the user to have to update the title of a record when they change the first name field or the last name field. I fully realize this will likely use reflection but I'm hoping some one out there can give me some pointers or even a working example to handle complex format strings that could be a mix if literal text and placeholders.
I've not had much luck looking for an implementation on the net that will do what I want since I'm not really sure what keywords would give me the most relevant search results?

You need two things:
1) A syntax for formatting strings
You have already described a syntax where variables are surrounded by bracers, and if you want to use that you need to build a parser that can parse that. Perhaps you also want to add ways to specify say a date or a number format.
2) Rules for resolving variables
If there is a single context object you can use reflection and match variable names to properties but if your object model is more complex you can add conventions for searching say a hierarchy of objects.
If you are planning to base your model objects on dynamic chances are that you will find the Clay library on CodePlex interesting.

Viewing a database over Collections, ORM Lists

I've been researching to find out how and what to use to get say the name's of the fields in a class, then to invoke that class and get the properties of the class, as in the field values.
Give you an example, Say if I one to get one value from one record from one table, I would create an object of that class as in;
DBTable<cars> cartable = new DBTable<cars>(1) //passing 1 is a dataset number
cartable.GetLastRec(); OR cartable.Attributes.Key.carIdx // record index
cartable.GetKeyRec();
// Now I print the value
Console.WriteLine("Car number: " + cartable.Attributes.Data.number;
It's easy to get one record, it's like an Object Orientated Database but not sure if it isn't, I don't have any knowledge of the database system, just that the classes are used to talk to a DLL file and pass some numbers.
so far I've been testing with collections, inheriting, ORM, and nothing seams to be able to describe the very simple process going on, Even dynamic invoking objects and iterating over it's attributes
What I hope do is;
Datagridview => Table Classes => DLL entry points => Database
If anyone has had the same challenge or maybe I have the wrong approach here, but completely lost at this stage, Any Idea's welcome
Thanks in Advance
btw: I'm using VS2005, .NET 2.0

The only way to do this is by providing your own PropertyDescriptorCollection.
A search here or on Google, should point you in the correct direction.