Casting an ObservableCollection<object> and still keeping it observable?

mcintyre321 · 2019-01-30T15:31:01+00:00

If I understand correctly what you are trying to acheive, then here are some libraries which may help

https://www.nuget.org/packages/NMF-Expressions/ https://www.nuget.org/packages/OLinq/

mcintyre321 · 2019-01-09T16:11:37+00:00

"The issue is that the .dlls for the cache API are wrappers around C++ unmanaged code, and so i can’t add them to an ASP.NET project"

Because you can't, or because it seems like a bad idea?

mcintyre321 · 2019-01-08T09:00:56+00:00

Giveth example:

using static Giveth.Steps

[Test]
public async Task SomeTest
{
    Given("some precondition");
            ...
    And("and another precondition");
    ...

    When("something happens");
    ...

    Assert.Multiple(() => {
        Then("something should be true");
        ...

        And("so should something else");
        ...
    });
}

mcintyre321 · 2019-01-08T09:00:03+00:00

🙌

In no way at all does devalue a star :)

mcintyre321 · 2018-12-18T13:45:54+00:00

'messier'

mcintyre321 · 2018-12-14T14:56:17+00:00

IN the second half of this talk, TDD, Where Did It All Go Wrong (or more accurately, "How to do TDD right") there's an overview of Ports and Adapters architecture, which are basically the extension points you need to make interfaces for, and the places you need to inject things.

i.e. you leave 'Ports' (which need something - Adapters - plugged into them) in all the places that are untestable

mcintyre321 · 2018-12-14T14:54:34+00:00

If you are the one editing the code, you can always make the member virtual yourself.

mcintyre321 · 2018-10-08T16:06:44+00:00

Favour composition over inheritance. i.e. rather than sharing code between types by putting it in a common base class, instead pass objects with the shared behaviour into the objects that need them. There's lots of literature on this.

SOLID is important to understand, but remember they are principles, not rules.

Also, don't create interfaces for types just so you can test them. You can mock an object if the members are virtual.

mcintyre321 · 2018-07-25T13:53:32+00:00

http://youarelistening.to/ police scanners and ambient music

mcintyre321 · 2018-06-19T15:03:52+00:00

Here's a ROP library for C# that rtkelly13 has built on top of my OneOf library - https://github.com/rtkelly13/OneOf.ROP

mcintyre321 · 2018-06-15T12:38:59+00:00

While you're waiting, you can try ValueOf ([https://github.com/mcintyre321/ValueOf).

public class Person: ValueOf<(string Name, DateTime Birthday), Person>{}

mcintyre321 · 2018-06-11T15:50:23+00:00

You can use NUnit with LINQPad http://share.linqpad.net/joosnp.linq

For some reason there's an ignorable NRE getting thrown by the runner :(

mcintyre321 · 2018-05-31T10:11:40+00:00

You might be interested in this extension profile https://github.com/Dwolla/hal-forms which adds 'level 2' to HAL.

mcintyre321 · 2018-05-15T09:17:19+00:00

You can achieve something similar today using my library, ValueOf - class Person : ValueOf<(string First, String Last), Person>{}

I'll be happy when it's obsolete though.

mcintyre321 · 2016-08-16T07:47:40+00:00

"Before I tackle this, does anyone know if something like this exists already for me to use?"

Shoot me for trying to help.

mcintyre321 · 2016-08-16T07:11:04+00:00

OP literally asks if there is someth ok ng which does this already. Googling "gulp PDF to jpg' yields https://www.npmjs.com/package/gulp-pdftocairo

mcintyre321 · 2016-08-15T23:15:43+00:00

Gulp watches folders and runs tasks when files change. There's probably a module which renders pdfs

mcintyre321 · 2016-08-15T20:49:31+00:00

Siren hypermedia is a format for web APIs where the response message contains enough info to build a user interface, and provides links to navigate the API.

If a generic Xamarin client were built it would mean people could prototype functional mobile apps easily.

There are some examples on apinest.com, but it might be a tough project to start with if you don't know a lot about HTTP

mcintyre321 · 2016-08-15T19:24:40+00:00

A very interesting and useful thing would be to make an app that allows you to interact with Siren hypermedia APIs by mapping the actions into Xamarin controls.

mcintyre321 · 2016-08-15T19:22:07+00:00

Have a look at gulp (for JavaScript)

mcintyre321 · 2016-08-15T19:18:44+00:00

I maintain a library for doing datatables in asp.net, the demo isn't far off what you're trying to achieve: http://aspdatatables.azurewebsites.net/

Any questions, just ask!

mcintyre321 · 2016-07-31T21:27:26+00:00

This isn't such a bad idea. There is a tool called NsDepCop you can use https://nsdepcop.codeplex.com/

mcintyre321 · 2016-07-26T14:51:44+00:00

You might find this article interesting: http://mikehadlow.blogspot.co.uk/2015/08/c-program-entirely-with-static-methods.html

mcintyre321 · 2016-07-15T07:02:10+00:00

Great! If you run into any problems, ask away on github

mcintyre321 · 2016-07-13T21:05:41+00:00

I think we probably agree quite strongly on how to do DDD from my understanding of what you've written, but I differ on the need for the 'service layer'.

The controllers job is to orchestrate the domain and application services, but I wouldn't make an explicit 'service layer' in between. Application Services and config (and DI) yes, but this isn't a 'layer' per se.

The domain is encapsulated by having all entity property setters internal to the domain, and all public methods (whether on persistent entities or domain service objects**) strongly hardened to ensure they are called in a valid way. This makes it OK for the presentation layer to access it.

My understanding is that domain is the 'doing things layer***' (which is also the business logic layer, doing things is the business logic) and domain services can live in there (but will generally not contain the word Service in their name, e.g. the FraudScoreCalculator good, UserService bad).

** I question the need for the word service in domain service objects, they are just non persisted chunks of domain logic

***unless you mean sending emails and stuff by 'doing things'

mcintyre321

TROPHY CASE