Piotr Stęclik – Developer documents

wiatrace.log – SSD killer

Zauważyłem przycinanie się Windowsa i duży strumień zapisywanych informacji. Winowajcą okazał się jakiś driver od drukarki EPSON, którego poskromienie nie przyniosło rezultatów. Skorzystałem więc z poniższego skryptu aby przekierować nichciane śmieci do /dev/null

net stop StiSvc
taskkill /f /t /im EEventManager.exe
cd \windows\debug\wia
del wiatrace.log && mklink wiatrace.log \\.\nul
del wiatrace.bak.log && mklink wiatrace.bak.log \\.\nul
"C:\Program Files (x86)\EPSON Software\Event Manager\EEventManager.exe"

net stop StiSvc

taskkill /f /t /im EEventManager.exe

cd \windows\debug\wia

del wiatrace.log && mklink wiatrace.log \\.\nul

del wiatrace.bak.log && mklink wiatrace.bak.log \\.\nul

"C:\Program Files (x86)\EPSON Software\Event Manager\EEventManager.exe"

Zatrzymanie serwisu musi się odbyć z poziomu administratora

Być jak Haskell

Historia kołem się toczy, więc po raz kolejny zabieram się do programowania bardziej funkcyjnego. Obejrzałem film Refactoring to Functional. a ponieważ jego autor Hadi Hariri pracuje obecnie dla JetBrains, to uznałem, że temat trzeba potraktować poważnie. W C# mamy dobrodziejstwa Linq, jednakże istnieje, że jego uniwersalność jest okupiona dużym narzutem. Unikam zatem Linq w miejscach, gdzie może […]

Dependency Injection według Microsoftu

Kto się boi zastrzyków? Na wskazanej poniżej stronie można dokładnie przeczytać o co chodzi z całym Dependency Injenction. Mówiąc w skrócie chodzi o to, aby pisząc program dostarczać małych kawałków kodu, które są łatwiejsze w tworzeniu, testowaniu i serwisowaniu zamiast monolitycznych gigantów przerośniętych gęstwiną splątanych zależności. Relacje pomiędzy komponentami powinny być realizowane przy użyciu wzorca Strategy, […]

Prosty API Controller

Kontynuuję zabawę z AspNetCore. W poprzednim artykule zrobiłem szkielet aplikacji, który udało się uruchomić. Rozgrzewka Czas na prosty kontroler API, który zwraca dane w postaci np. JSONa, które mogą zostać użyte np. w architekturze AJAX. W katalogu Controllers należy utworzyć nową klasę SimpleApiController, która dziedziczy z Controller. Do tej klasy dodajemy metodę Indeks zwracającą IActionResult.

using System;
using Microsoft.AspNetCore.Mvc;

namespace AspNetCoreTest.Controllers
{
    public class SimpleApiController : Controller
    {
        public IActionResult Index()
        {
            return Json(new
            {
                FirstName = "Piotr",
                LastName = "Nowak",
                LastUpdate = DateTime.Now
            });
        }
    }
}

using System;

using Microsoft.AspNetCore.Mvc;

namespace AspNetCoreTest.Controllers

{

public class SimpleApiController : Controller

{

public IActionResult Index()

{

return Json(new

{

FirstName = "Piotr",

LastName = "Nowak",

LastUpdate = DateTime.Now

});

}

Po skompilowaniu i […]

AspNetCore, pierwsze starcie

Postanowiłem zabrać się w końcu za przetestowanie AspNet Core. Po pierwsze stworzyłem nowy projekt Dlaczego .NET Framework? Otóż .NET Core uważam w tej chwili za mocno niedojrzały. Miałem pod górę w kilku projektach więc pomyślałem „jeszcze nie tym razem”. Kolejny krok to wybór szablonu. Wybrałem zwykłą „Web application” Po kilkudziesięciu sekundach projekt się stworzył, ściągnęły […]

Pożeracze pamięci

Wstęp Zauważyłem ostatnio dużą ilość pamięci zużywanej przez proces ID=4, t.j. System Bywa, że ilość pamięci sięga granicy grubo ponad gigabajt Jak znaleźć łakomczucha? Zabrałem się do poszukiwania winowajcy. Na początek pobrałem pakiet Windows Driver Kit (WDK), który zawiera narzędzie poolmon.

C:\Program Files (x86)\Windows Kits\10\Tools\x64\poolmon.exe

1	C:\Program Files (x86)\Windows Kits\10\Tools\x64\poolmon.exe

Po uruchomieniu i kliknięciu „B” (sortowanie po ilości bajtów) ukazał się pełen obraz: Lista […]

Magiczne async

W sieci jest wiele materiałów na temat konstrukcji async-away. Postanowiłem zbadać kilka ciekawostek. Użycie async bez away Rozważmy kod

using System;
using System.Threading.Tasks;

public class C {
    
     public async void Pierwsza() {
        var i = await test();
    }
    public async void Druga() {
        var i = test().Result;
    }
    
    Task<int> test() {
        return  Task.Run(() =>
            {
               return 1;
            });
    }     
}

using System;

using System.Threading.Tasks;

public class C {

public async void Pierwsza() {

var i = await test();

}

public async void Druga() {

var i = test().Result;

}

Task<int> test() {

return Task.Run(() =>

{

return 1;

});

}

Metoda „Pierwsza” jest napisana zgodnie ze sztuką. Budowa metody „Druga” budzi sprzeciw kompilatora:

(8,22,8,27): Warning CS1998: This async method lacks 'await' operators and will run synchronously. Consider using the 'await' operator to await non-blocking API calls, or 'await Task.Run(...)' to do CPU-bound work on a background thread.

1	(8,22,8,27): Warning CS1998: This async method lacks 'await' operators and will run synchronously. Consider using the 'await' operator to await non-blocking API calls, or 'await Task.Run(...)' to do CPU-bound work on a background thread.

Użyłem strony http://tryroslyn.azurewebsites.net aby obnażyć prawdę. Oto prawdziwy „kod pod spodem” (fragment)

    [AsyncStateMachine(typeof(C.<Pierwsza>d__1))]
    public void Pierwsza()
    {
        C.<Pierwsza>d__1 <Pierwsza>d__;
        <Pierwsza>d__.<>4__this = this;
        <Pierwsza>d__.<>t__builder = AsyncVoidMethodBuilder.Create();
        <Pierwsza>d__.<>1__state = -1;
        AsyncVoidMethodBuilder <>t__builder = <Pierwsza>d__.<>t__builder;
        <>t__builder.Start<C.<Pierwsza>d__1>(ref <Pierwsza>d__);
    }
    [AsyncStateMachine(typeof(C.<Druga>d__1))]
    public void Druga()
    {
        C.<Druga>d__1 <Druga>d__;
        <Druga>d__.<>4__this = this;
        <Druga>d__.<>t__builder = AsyncVoidMethodBuilder.Create();
        <Druga>d__.<>1__state = -1;
        AsyncVoidMethodBuilder <>t__builder = <Druga>d__.<>t__builder;
        <>t__builder.Start<C.<Druga>d__1>(ref <Druga>d__);
    }

[AsyncStateMachine(typeof(C.<Pierwsza>d__1))]

public void Pierwsza()

{

C.<Pierwsza>d__1 <Pierwsza>d__;

<Pierwsza>d__.<>4__this = this;

<Pierwsza>d__.<>t__builder = AsyncVoidMethodBuilder.Create();

<Pierwsza>d__.<>1__state = -1;

AsyncVoidMethodBuilder <>t__builder = <Pierwsza>d__.<>t__builder;

<>t__builder.Start<C.<Pierwsza>d__1>(ref <Pierwsza>d__);

}

[AsyncStateMachine(typeof(C.<Druga>d__1))]

public void Druga()

{

C.<Druga>d__1 <Druga>d__;

<Druga>d__.<>4__this = this;

<Druga>d__.<>t__builder = AsyncVoidMethodBuilder.Create();

<Druga>d__.<>1__state = -1;

AsyncVoidMethodBuilder <>t__builder = <Druga>d__.<>t__builder;

<>t__builder.Start<C.<Druga>d__1>(ref <Druga>d__);

}

Zabawa w „znajdź różnice” skutkuje tylko tym, że […]

Azure Quota Exceeded

Zaliczyłem „Quota Exceeded” na bazie MsSql w Azure. Ponieważ była to aplikacja testowa, to usunąłem wszystkie dane, z tabel. Zrobiłem rebuild indeksów i oczekiwałem odblokowania dostępu. Tymczasem ku mojemu zdziwieniu: Żadne 'refresh’ nie pomaga. Najciekawsze jest to, że na jednej stronie Azure podaje sprzeczne informacje.

Roslyn-rozpoznawanie typów wyrażeń

Pochylmy się nad następującym kodem

var x = 1;
decimal y = x;

1 2	var x = 1; decimal y = x;

Łatwo odgadnąć, że zmienna x jest typu int, natomiast podczas przypisania wartości x do zmiennej y następuje niejawne rzutowanie do typu decimal. Jak robi to Roslyn? Napiszmy testowy kod

const string sampleCode = @"using System;
public class Foo
{
    public void Y()
    {
        int x = 1;
        decimal y = x;
    }
}
";
var tree = SyntaxFactory.ParseSyntaxTree(sampleCode);
var cSharpCompilation = CSharpCompilation.Create("MyCompilation",
syntaxTrees: new[] { tree }, references: new[] { MscorlibRef });
var semanticModel = cSharpCompilation.GetSemanticModel(tree);

var declarations = tree.GetRoot().DescendantNodes()
    .OfType<LocalDeclarationStatementSyntax>()
    .ToArray();
Debug.Assert(declarations != null && declarations.Length == 2);
foreach (var localDeclarationStatementSyntax in declarations)
{
    var declaration = localDeclarationStatementSyntax.Declaration;
    foreach (var variableDeclaratorSyntax in declaration.Variables)
    {
        var initializer = variableDeclaratorSyntax.Initializer;
        if (initializer==null)
            continue;
        var initializerValue = initializer.Value;
        var initializerValueType = semanticModel.GetTypeInfo(initializerValue);
        Console.WriteLine("{0} {1} {2}", variableDeclaratorSyntax, initializerValueType.Type, initializerValueType.ConvertedType);
    }           
}

const string sampleCode = @"using System;

public class Foo

{

public void Y()

{

int x = 1;

decimal y = x;

}

var tree = SyntaxFactory.ParseSyntaxTree(sampleCode);

var cSharpCompilation = CSharpCompilation.Create("MyCompilation",

syntaxTrees: new[] { tree }, references: new[] { MscorlibRef });

var semanticModel = cSharpCompilation.GetSemanticModel(tree);

var declarations = tree.GetRoot().DescendantNodes()

.OfType<LocalDeclarationStatementSyntax>()

.ToArray();

Debug.Assert(declarations != null && declarations.Length == 2);

foreach (var localDeclarationStatementSyntax in declarations)

{

var declaration = localDeclarationStatementSyntax.Declaration;

foreach (var variableDeclaratorSyntax in declaration.Variables)

{

var initializer = variableDeclaratorSyntax.Initializer;

if (initializer==null)

continue;

var initializerValue = initializer.Value;

var initializerValueType = semanticModel.GetTypeInfo(initializerValue);

Console.WriteLine("{0} {1} {2}", variableDeclaratorSyntax, initializerValueType.Type, initializerValueType.ConvertedType);

}

Na konsoli otrzymamy wynik:

x = 1 int int
y = x int decimal

1 2	x = 1 int int y = x int decimal

Co jednak gdybyśmy chcieli dowiedzieć się czegoś więcej o rzutowaniu typów. Rozważmy kod:

using System;
public class XNumber {
    public XNumber(int x) { 
       _x = x;
    }
    int _x;
    public static implicit operator int(XNumber src)
    {
       return src._x;
    }
}
public class Foo
{
    public void Y()
    {
        XNumber x = new XNumber(1);
        decimal y = x;
        int z = x;
    }
}

using System;

public class XNumber {

public XNumber(int x) {

_x = x;

}

int _x;

public static implicit operator int(XNumber src)

{

return src._x;

}

public class Foo

{

public void Y()

{

XNumber x = new XNumber(1);

decimal y = x;

int z = x;

}

[…]

Raspberry PI i Arduino – bezprzewodowo

Po udanym połączeniu dwóch jednostek Arduino poprzez moduł nRF24L01+ narobiłem sobie apetytu na połączenie bezprzewodowe Arduino z Raspberrym i uczynienie z RPI koncentratora zbierającego rozmaite dane. Krok po kroku podążałem za artykułem Communicating from low power Arduino to Raspberry Pi via NRF24L01 . Po drodze potknąłem się kilka razy i o tym jest ten post. […]