How to create exclusive classes?

[=?Utf-8?B?RGFiYmxlck5M?=]

I have the following Methods:

public SecondResult DoSomething()
{
FirstResult firstResult=GetFirstResult();
SecondResult secondResult=GetSecondResult(firstResult);
return secondResult;
}

private FirstResult GetFirstResult()
{...}

private SecondResult(FirstResult fr)
{...}

The Method GetSecondResult should only and only then be called after
GetFirstResult has been called. To achieve that I want that the only way to
obtain a SecondResult object is through calling the FirstResult method.

This compares to the IOrderedEnumerable<Ttype that is returned from the
OrderBy and OrderByDescending(IEnumerable<T>) methods, so that it is ensured
that the ThenBy and ThenByDescending(IOrderedEnumerable<T>) methods can only
be used after application of a OrderBy method.

How do I achieve this?

[Peter Duniho]

On Thu, 13 Nov 2008 00:10:00 -0800, DabblerNL <Da*****@communty.nospam>
wrote:

I have the following Methods:

public SecondResult DoSomething()
{
FirstResult firstResult=GetFirstResult();
SecondResult secondResult=GetSecondResult(firstResult);
return secondResult;
}

private FirstResult GetFirstResult()
{...}

private SecondResult(FirstResult fr)
{...}

The Method GetSecondResult should only and only then be called after
GetFirstResult has been called. To achieve that I want that the only way
to
obtain a SecondResult object is through calling the FirstResult method.

[...]
How do I achieve this?

What problem are you having? The above seems reasonably straightforward.
What specific question do you have?

By the way, rather than having two methods in the same class, one which
operates on the instantiated class (i.e. "FirstResult"), it might make
sense for the second method to actually be an instance method of the
instantiated class. Functionally it would be basically the same,
depending on how you construct the class "FirstResult", but it may provide
better encapsulation of your intermediate results (I can't say for sure,
because there are so few actual details in your proposal...but I think it
probably would).

Pete

[=?Utf-8?B?RGFiYmxlck5M?=]

Hello Pete,

Thanks for you answer. I am not having a problem really. My code works fine.
I am just exploring different programming techniques.
What I want is to create code that ensures that some methods can only be
called after some other methods have been called first, because these
previous methods assing some values to the properties of the class that the
later methods work on.

The .Net Methods OrderBy and ThenBy do exactly that.: ThenBy works on a
IOrderedEnumerable<T>, which is the return value of the OrderBy Method. As
far as I know there is no other way to create a IOrderedEnumerable<Tthan
vby using OrderBy. I like that approach but are wondering how it is done.

I will try your suggestion of moving the GetSecondResult Method to the
FirstResult class. It will not make the code necessarily more readible though.

My real code is:

public List<SeatingSeatCellList(List<Cellcells)
{
cells.Seat();//will set some properties in the cells in the List
return AdaptToSeatingList(cells);//reads the properties that are change
and makes a List<Seating>
}

private List<SeatingAdaptToSeatingList(List<Cellcells)
{
var result=new List<Seating>
// do some work on the cells
return result;
}

As you see the AdaptToSeatingList Method accepts a List<Cellbut it
requiers that some properties of the elements of this list are assigned to.
This can be solved by doing some error checking inside the AdaptToSeatingList
method, but this is ugly. I would rather have the Seat() (extension) method
of the List<Cellreturn a List<SeatedCellsand have the AdaptToSeatingList
method accept this type as an argument. This is not difficult to achieve, but
I would like to ensure that the only way to get a List<SeatedCellsis
through the List<Cell>.Seat() method.
How??
"Peter Duniho" wrote:

On Thu, 13 Nov 2008 00:10:00 -0800, DabblerNL <Da*****@communty.nospam>
wrote:

I have the following Methods:

public SecondResult DoSomething()
{
FirstResult firstResult=GetFirstResult();
SecondResult secondResult=GetSecondResult(firstResult);
return secondResult;
}

private FirstResult GetFirstResult()
{...}

private SecondResult(FirstResult fr)
{...}

The Method GetSecondResult should only and only then be called after
GetFirstResult has been called. To achieve that I want that the only way
to
obtain a SecondResult object is through calling the FirstResult method.

[...]
How do I achieve this?

What problem are you having? The above seems reasonably straightforward.
What specific question do you have?

By the way, rather than having two methods in the same class, one which
operates on the instantiated class (i.e. "FirstResult"), it might make
sense for the second method to actually be an instance method of the
instantiated class. Functionally it would be basically the same,
depending on how you construct the class "FirstResult", but it may provide
better encapsulation of your intermediate results (I can't say for sure,
because there are so few actual details in your proposal...but I think it
probably would).

Pete

[Peter Duniho]

On Thu, 13 Nov 2008 06:43:01 -0800, DabblerNL <an**@newsgroup.nospam>
wrote:

[...]
The .Net Methods OrderBy and ThenBy do exactly that.: ThenBy works on a
IOrderedEnumerable<T>, which is the return value of the OrderBy Method.
As
far as I know there is no other way to create a IOrderedEnumerable<T>
than
vby using OrderBy. I like that approach but are wondering how it is done.

There's nothing magic about it. In fact, it's not true that "there is no
other way to create an IOrderedEnumerable<TElement>". You can implement
the interface yourself if you like, and pass an instance of that
implementation to the methods that take it. As long as your
implementation behaves correctly, then everything will work fine. But, if
your implementation does not, there's nothing in LINQ that can enforce
that and ensure correct behavior in spite of it.

[...] I would rather have the Seat() (extension) method
of the List<Cellreturn a List<SeatedCellsand have the
AdaptToSeatingList
method accept this type as an argument. This is not difficult to
achieve, but
I would like to ensure that the only way to get a List<SeatedCellsis
through the List<Cell>.Seat() method.
How??

What you're asking for is not literally possible. Any code that knows the
SeatedCells type can create a List<SeatedCells>.

You can limit the opportunity for other code to do that by making the type
private nested within your outer class (and it's possible that would be a
good idea anyway, if all of this logic is private to the outer class), but
that won't stop code from within your outer class from misusing the type.

But note that this isn't really like the code you originally posted. In
particular, the type being passed around isn't your own type, but rather a
public type containing your own type. If the type being passed around was
in fact your own type, then you could provide better guarantees, by
putting the logic required to apply whatever state you want into the
constructor itself. That would make it impossible to get an instance of
that type without initializing it in just the way you want.

So, one approach you might do is wrap the List<Cellsinside a type of
your own making. For it to be truly protected, you would have to copy in
the original List<Cells>, otherwise some caller could potentially modify
the List<Cellspassed to the constructor after the fact. Your wrapper
class could contain the implementation of your "AdaptToSeatingList()"
method, or the wrapper class could provide whatever access to the list is
required by the "AdaptToSeatingList()" method (e.g. you could implement
the IList<Cellsinterface, and then have the "AdaptToSeatingList()"
method work on an IList<Cells>, rather than the specific List<Cells>).

Pete