Theoretical doubt - Interface, unique responsibility

Question

Presentation:

I created a photo.Cs class that should be responsible for:

• Calculate the angle of view of the lens;
• Receive lens zoom (in mm)
• Receive the cut factor (value multiplied by the lens zoom shows the actual lens value)
• Dimensions of the camera sensor, etc.

I thought about creating the interface, more for academic purposes than practical.

Interface

namespace fotografia
{
    public enum _CamerasFabricante { Canon=0, Nikon = 1, Sony = 2 };
    public interface IFotografia
    {
        int CameraFabricante(_CamerasFabricante _value);
        double FatordeCorte { get; set; }
        int ObjetivaMM { get; set; }

        double SensorHmm { get; set; }
        double SensorVmm { get; set; }
        double CalculoAnguloVisaoH();
        double CalculoAnguloVisaoV();
    }
}

so I created the class for this interface:

using System;

namespace fotografia
{
    internal class fotografia : IFotografia
    {
        public double FatordeCorte { get; set; }

        public int ObjetivaMM { get; set; }

        public int CameraFabricante(_CamerasFabricante _value)
        {
            return (int)_value;
        }

        private double _MMFinalObjetiva()
        {
            return (Convert.ToDouble(ObjetivaMM) * FatordeCorte);
        }

        public double SensorHmm
        {
            get;
            set;
        }

        private double myVar;

        public double SensorVmm
        {
            get { return myVar; }
            set { myVar = value; }
        }

        public double CalculoAnguloVisaoH()
        {
            double fov = SensorHmm / (2 * _MMFinalObjetiva());

            double arctan = 2 * Math.Atan(fov)  * 180.0 / Math.PI;
            return arctan;
        }

        private double CalculoAnguloVisaoV()
        {
            double fov = SensorVmm / (2 * _MMFinalObjetiva());

            double arctan = 2 * Math.Atan(fov) * 180.0 / Math.PI;
            return arctan;
        }
    }
}

Doubts:

1. Is this class doing more than it should? because each method really does only 1 thing, but the photography class does everything in relation to photography. On the sole responsibility this correct?
2. I implemented the Interface and the class correctly?

I’m calling it that on the show

IFotografia ft = new fotografia();
            ft.CameraFabricante(_CamerasFabricante.Canon);
            ft.ObjetivaMM = 50;
            ft.SensorHmm = 22.3;
            ft.FatordeCorte = 1.6;
            var t = ft.CalculoAnguloVisaoH();

Answer 1

The principle of sole responsibility is part of the principles SOLID created by Robert C. Martin as a design guide to follow in your code but not as a must.

Removed from the documentation of the principles:

In the context of the Principle of Sole Responsibility we define responsibility as being "the reason for change". If you think of one or more reasons to change a class, then this class has more than one responsibility. That’s hard to watch sometimes. We are used to thinking of group responsibilities. For example consider the following Modem interface:

public interface Modem
{

    public void Dial(string pno);
    public void Hangup();
    public void Send(char c);
    public char Recv();
}

Most of us agree that this interface seems perfectly reasonable. The four functions it declares are certainly functions belonging to a modem.

Of any were there are two responsibilities shown here. The first is connection management. The second is data communication. Dial and hangup functions manage modem connection, while send and recv functions communicate data.

Should these two responsibilities be separated? This will depend on how the application will change.

Here has a more complete description of the principles.

Soon to answer this principle you should keep in mind how your application will change. If you’re gonna change these things:

1. Calculate the angle of view of the lens;
2. Receive lens zoom (in mm)
3. Receive the cut factor (value multiplied by the lens zoom shows the actual lens value)
4. Dimensions of the camera sensor, etc.

So your class has many responsibilities, if not modify it is fully compatible with this principle.

Answer 2

This is correct, but you should also create the methods in the interface, not only the properties.

public enum _CamerasFabricante { Canon=0, Nikon = 1, Sony = 2 };
public interface IFotografia
{
    int CameraFabricante(_CamerasFabricante _value);
    double FatordeCorte { get; set; }
    int ObjetivaMM { get; set; }

    double SensorHmm { get; set; }
    double SensorVmm { get; set; }

    double CalculoAnguloVisaoH()
    double CalculoAnguloVisaoV()
}